Maximal Subgroups and Branching Rules¶

What’s in a branching rule?¶

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 $Lie (T)^{*}$ , we get map $Lie (T)^{*} \to Lie (U)^{*}$ , and this must be implemented as a function. For speed, the function usually just returns a list, which can be coerced into $Lie (U)^{*}$ .

Sage

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]

Python

>>> from sage.all import *
>>> b = branching_rule("A3","C2","symmetric")
>>> 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]

Sage Live

b = branching_rule("A3","C2","symmetric")
for r in RootSystem("A3").ambient_space().simple_roots():
    print("{} {}".format(r, b(r)))

We could conjugate this map by an element of the Weyl group of $G$ , and the resulting map would give the same decomposition of representations of $G$ into irreducibles of $H$ . However it is a good idea to choose the map so that it takes dominant weights to dominant weights, and, insofar as possible, simple roots of $G$ into simple roots of $H$ . This includes sometimes the affine root $α_{0}$ of $G$ , which we recall is the negative of the highest root.

The branching rule has a describe() method that shows how the roots (including the affine root) restrict. This is a useful way of understanding the embedding. You might want to try it with various branching rules of different kinds, "extended", "symmetric", "levi" etc.

Sage

sage: b.describe()

0
O-------+
|       |
|       |
O---O---O
1   2   3
A3~

root restrictions A3 => C2:

O=<=O
1   2
C2

1 => 1
2 => 2
3 => 1

For more detailed information use verbose=True

Python

>>> from sage.all import *
>>> 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

Sage Live

b.describe()

The extended Dynkin diagram of $G$ and the ordinary Dynkin diagram of $H$ are shown for reference, and 3 => 1 means that the third simple root $α_{3}$ of $G$ restricts to the first simple root of $H$ . In this example, the affine root does not restrict to a simple roots, so it is omitted from the list of restrictions. If you add the parameter verbose=true you will be shown the restriction of all simple roots and the affine root, and also the restrictions of the fundamental weights (in coroot notation).

Subgroups classified by the extended Dynkin diagram¶

It is also true that if we remove one node from the extended Dynkin diagram that we obtain the Dynkin diagram of a subgroup. For example:

Sage

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

Python

>>> from sage.all import *
>>> G2 = WeylCharacterRing("G2", style="coroots")
>>> G2.extended_dynkin_diagram()
  3
O=<=O---O
1   2   0
G2~

Sage Live

G2 = WeylCharacterRing("G2", style="coroots")
G2.extended_dynkin_diagram()

Observe that by removing the 1 node that we obtain an $A_{2}$ Dynkin diagram. Therefore the exceptional group $G_{2}$ contains a copy of $S L (3)$ . We branch the two representations of $G_{2}$ corresponding to the fundamental weights to this copy of $A_{2}$ :

Sage

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

Python

>>> from sage.all import *
>>> G2 = WeylCharacterRing("G2", style="coroots")
>>> A2 = WeylCharacterRing("A2", style="coroots")
>>> [G2(f).degree() for f in G2.fundamental_weights()]
[7, 14]
>>> [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)]

Sage Live

G2 = WeylCharacterRing("G2", style="coroots")
A2 = WeylCharacterRing("A2", style="coroots")
[G2(f).degree() for f in G2.fundamental_weights()]
[G2(f).branch(A2, rule="extended") for f in G2.fundamental_weights()]

The two representations of $G_{2}$ , of degrees 7 and 14 respectively, are the action on the octonions of trace zero and the adjoint representation.

For embeddings of this type, the rank of the subgroup $H$ is the same as the rank of $G$ . This is in contrast with embeddings of Levi type, where $H$ has rank one less than $G$ .

Levi subgroups of $G_{2}$ ¶

The exceptional group $G_{2}$ has two Levi subgroups of type $A_{1}$ . Neither is maximal, as we can see from the extended Dynkin diagram: the subgroups $A_{1} \times A_{1}$ and $A_{2}$ are maximal and each contains a Levi subgroup. (Actually $A_{1} \times A_{1}$ contains a conjugate of both.) Only the Levi subgroup containing the short root is implemented as an instance of rule="levi". To obtain the other, use the rule:

Sage

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

Python

>>> from sage.all import *
>>> branching_rule("G2","A2","extended")*branching_rule("A2","A1","levi")
composite branching rule G2 => (extended) A2 => (levi) A1

Sage Live

branching_rule("G2","A2","extended")*branching_rule("A2","A1","levi")

which branches to the $A_{1}$ Levi subgroup containing a long root.

Non-maximal Levi subgroups and Projection from Reducible Types¶

Not all Levi subgroups are maximal. Recall that the Dynkin-diagram of a Levi subgroup $H$ of $G$ is obtained by removing a node from the Dynkin diagram of $G$ . Removing the same node from the extended Dynkin diagram of $G$ results in the Dynkin diagram of a subgroup of $G$ that is strictly larger than $H$ . However this subgroup may or may not be proper, so the Levi subgroup may or may not be maximal.

If the Levi subgroup is not maximal, the branching rule may or may not be implemented in Sage. However if it is not implemented, it may be constructed as a composition of two branching rules.

For example, prior to Sage-6.1 branching_rule("E6","A5","levi") returned a not-implemented error and the advice to branch to A5xA1. And we can see from the extended Dynkin diagram of $E_{6}$ that indeed $A_{5}$ is not a maximal subgroup, since removing node 2 from the extended Dynkin diagram (see below) gives A5xA1. To construct the branching rule to $A_{5}$ we may proceed as follows:

Sage

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

        O 0
        |
        |
        O 2
        |
        |
O---O---O---O---O
1   3   4   5   6
E6~
root restrictions E6 => A5:

O---O---O---O---O
1   2   3   4   5
A5

0 => (zero)
1 => 1
3 => 2
4 => 3
5 => 4
6 => 5

For more detailed information use verbose=True

Python

>>> from sage.all import *
>>> b = branching_rule("E6","A5xA1","extended")*branching_rule("A5xA1","A5","proj1"); b
composite branching rule E6 => (extended) A5xA1 => (proj1) A5
>>> E6 = WeylCharacterRing("E6",style="coroots")
>>> A5 = WeylCharacterRing("A5",style="coroots")
>>> E6(Integer(0),Integer(1),Integer(0),Integer(0),Integer(0),Integer(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)
>>> 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

Sage Live

b = branching_rule("E6","A5xA1","extended")*branching_rule("A5xA1","A5","proj1"); b
E6 = WeylCharacterRing("E6",style="coroots")
A5 = WeylCharacterRing("A5",style="coroots")
E6(0,1,0,0,0,0).branch(A5,rule=b)
b.describe()

Note that it is not necessary to construct the Weyl character ring for the intermediate group A5xA1.

This last example illustrates another common problem: how to extract one component from a reducible root system. We used the rule "proj1" to extract the first component. We could similarly use "proj2" to get the second, or more generally any combination of components:

Sage

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

Python

>>> from sage.all import *
>>> branching_rule("A2xB2xG2","A2xG2","proj13")
proj13 branching rule A2xB2xG2 => A2xG2

Sage Live

branching_rule("A2xB2xG2","A2xG2","proj13")

Symmetric subgroups¶

If $G$ admits an outer automorphism (usually of order two) then we may try to find the branching rule to the fixed subgroup $H$ . It can be arranged that this automorphism maps the maximal torus $T$ to itself and that a maximal torus $U$ of $H$ is contained in $T$ .

Suppose that the Dynkin diagram of $G$ admits an automorphism. Then $G$ itself admits an outer automorphism. The Dynkin diagram of the group $H$ of invariants may be obtained by “folding” the Dynkin diagram of $G$ along the automorphism. The exception is the branching rule $G L (2 r) \to S O (2 r)$ .

Here are the branching rules that can be obtained using rule="symmetric".

$G$	$H$	Cartan Types
$G L (2 r)$	$S p (2 r)$	`['A',2r-1] => ['C',r]`
$G L (2 r + 1)$	$S O (2 r + 1)$	`['A',2r] => ['B',r]`
$G L (2 r)$	$S O (2 r)$	`['A',2r-1] => ['D',r]`
$S O (2 r)$	$S O (2 r - 1)$	`['D',r] => ['B',r-1]`
$E_{6}$	$F_{4}$	`['E',6] => ['F',4]`

Tensor products¶

If $G_{1}$ and $G_{2}$ are Lie groups, and we have representations $π_{1} : G_{1} \to G L (n)$ and $π_{2} : G_{2} \to G L (m)$ then the tensor product is a representation of $G_{1} \times G_{2}$ . It has its image in $G L (n m)$ but sometimes this is conjugate to a subgroup of $S O (n m)$ or $S p (n m)$ . In particular we have the following cases.

Group	Subgroup	Cartan Types
$G L (r s)$	$G L (r) \times G L (s)$	`['A', rs-1] => ['A',r-1] x ['A',s-1]`
$S O (4 r s + 2 r + 2 s + 1)$	$S O (2 r + 1) \times S O (2 s + 1)$	`['B',2rs+r+s] => ['B',r] x ['B',s]`
$S O (4 r s + 2 s)$	$S O (2 r + 1) \times S O (2 s)$	`['D',2rs+s] => ['B',r] x ['D',s]`
$S O (4 r s)$	$S O (2 r) \times S O (2 s)$	`['D',2rs] => ['D',r] x ['D',s]`
$S O (4 r s)$	$S p (2 r) \times S p (2 s)$	`['D',2rs] => ['C',r] x ['C',s]`
$S p (4 r s + 2 s)$	$S O (2 r + 1) \times S p (2 s)$	`['C',2rs+s] => ['B',r] x ['C',s]`
$S p (4 r s)$	$S p (2 r) \times S O (2 s)$	`['C',2rs] => ['C',r] x ['D',s]`

These branching rules are obtained using rule="tensor".

Symmetric powers¶

The $k$ -th symmetric and exterior power homomorphisms map $G L (n) \to G L ((\binom{n + k - 1}{k}))$ and $G L ((\binom{n}{k}))$ . The corresponding branching rules are not implemented but a special case is. The $k$ -th symmetric power homomorphism $S L (2) \to G L (k + 1)$ has its image inside of $S O (2 r + 1)$ if $k = 2 r$ and inside of $S p (2 r)$ if $k = 2 r - 1$ . Hence there are branching rules:

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

and these may be obtained using rule="symmetric_power".

Miscellaneous other subgroups¶

Use rule="miscellaneous" for the following rules. Every maximal subgroup $H$ of an exceptional group $G$ are either among these, or the five $A_{1}$ subgroups described in the next section, or (if $G$ and $H$ have the same rank) is available using rule="extended".

$\begin{array}{r} \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{array}$

The first rule corresponds to the embedding of $G_{2}$ in $SO (7)$ in its action on the trace zero octonions. The two branching rules from $E_{6}$ to $G_{2}$ or $A_{2}$ are described in [Testerman1989]. We caution the reader that Theorem G.2 of that paper, proved there in positive characteristic is false over the complex numbers. On the other hand, the assumption of characteristic $p$ is not important for Theorems G.1 and A.1, which describe the torus embeddings, hence contain enough information to compute the branching rule. There are other ways of embedding $G_{2}$ or $A_{2}$ into $E_{6}$ . These may embeddings be characterized by the condition that the two 27-dimensional representations of $E_{6}$ restrict irreducibly to $G_{2}$ or $A_{2}$ . Their images are maximal subgroups.

The remaining rules come about as follows. Let $G$ be $F_{4}$ , $E_{6}$ , $E_{7}$ or $E_{8}$ , and let $H$ be $G_{2}$ , or else (if $G = E_{7}$ ) $F_{4}$ . We embed $H$ into $G$ in the most obvious way; that is, in the chain of subgroups

$G_{2} \subset F_{4} \subset E_{6} \subset E_{7} \subset E_{8}$

Then the centralizer of $H$ is $A_{1}$ , $A_{2}$ , $C_{3}$ , $F_{4}$ (if $H = G_{2}$ ) or $A_{1}$ (if $G = E_{7}$ and $H = F_{4}$ ). This gives us five of the cases. Regarding the branching rule $E_{6} \to G_{2} \times A_{2}$ , Rubenthaler [Rubenthaler2008] describes the embedding and applies it in an interesting way.

The embedding of $A_{1} \times A_{1}$ into $E_{7}$ is as follows. Deleting the 5 node of the $E_{7}$ Dynkin diagram gives the Dynkin diagram of $A_{4} \times A_{2}$ , so this is a Levi subgroup. We embed $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).

The embedding if $G_{2} \times A_{1}$ into $E_{7}$ is as follows. Deleting the 2 node of the $E_{7}$ Dynkin diagram gives the $A_{6}$ Dynkin diagram, which is the Levi subgroup $SL (7)$ . We embed $G_{2}$ into $SL (7)$ via the irreducible seven-dimensional representation of $G_{2}$ . The $A_{1}$ is the centralizer.

The embedding if $A_{2} \times 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 $SL (8)$ . We embed $A_{2}$ into $SL (8)$ via the irreducible eight-dimensional adjoint representation of $SL (2)$ . The $A_{1}$ is the centralizer.

The embedding $A_{2}$ into $E_{7}$ is proved in [Seitz1991] (5.8). In particular, he computes the embedding of the $SL (3)$ torus in the $E_{7}$ torus, which is what is needed to implement the branching rule. The embedding of $B_{2}$ into $E_{8}$ is also constructed in [Seitz1991] (6.7). The embedding of the $B_{2}$ Cartan subalgebra, needed to implement the branching rule, is easily deduced from (10) on page 111.

Maximal A1 subgroups of Exceptional Groups¶

There are seven embeddings of $S L (2)$ into an exceptional group as a maximal subgroup: one each for $G_{2}$ and $F_{4}$ , two nonconjugate embeddings for $E_{7}$ and three for $E_{8}$ These are constructed in [Testerman1992]. Create the corresponding branching rules as follows. The names of the rules are roman numerals referring to the seven cases of Testerman’s Theorem 1:

Sage

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

Python

>>> from sage.all import *
>>> branching_rule("G2","A1","i")
i branching rule G2 => A1
>>> branching_rule("F4","A1","ii")
ii branching rule F4 => A1
>>> branching_rule("E7","A1","iii")
iii branching rule E7 => A1
>>> branching_rule("E7","A1","iv")
iv branching rule E7 => A1
>>> branching_rule("E8","A1","v")
v branching rule E8 => A1
>>> branching_rule("E8","A1","vi")
vi branching rule E8 => A1
>>> branching_rule("E8","A1","vii")
vii branching rule E8 => A1

Sage Live

branching_rule("G2","A1","i")
branching_rule("F4","A1","ii")
branching_rule("E7","A1","iii")
branching_rule("E7","A1","iv")
branching_rule("E8","A1","v")
branching_rule("E8","A1","vi")
branching_rule("E8","A1","vii")

The embeddings are characterized by the root restrictions in their branching rules: usually a simple root of the ambient group $G$ restricts to the unique simple root of $A_{1}$ , except for root $α_{4}$ for rules iv, vi and vii, and the root $α_{6}$ for root vii; this is essentially the way Testerman characterizes the embeddings, and this information may be obtained from Sage by employing the describe() method of the branching rule. Thus:

Sage

sage: branching_rule("E8","A1","vii").describe()

        O 2
        |
        |
O---O---O---O---O---O---O---O
1   3   4   5   6   7   8   0
E8~
root restrictions E8 => A1:

O
1
A1

1 => 1
2 => 1
3 => 1
4 => (zero)
5 => 1
6 => (zero)
7 => 1
8 => 1

For more detailed information use verbose=True

Python

>>> from sage.all import *
>>> 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 Live

branching_rule("E8","A1","vii").describe()

Writing your own branching rules¶

Sage has many built-in branching rules. Indeed, at least up to rank eight (including all the exceptional groups) branching rules to all maximal subgroups are implemented as built in rules, except for a few obtainable using branching_rule_from_plethysm. This means that all the rules in [McKayPatera1981] are available in Sage.

Still in this section we are including instructions for coding a rule by hand. As we have already explained, the branching rule is a function from the weight lattice of G to the weight lattice of H, and if you supply this you can write your own branching rules.

As an example, let us consider how to implement the branching rule A3 -> C2. Here H = C2 = Sp(4) embedded as a subgroup in A3 = GL(4). The Cartan subalgebra $Lie (U)$ consists of diagonal matrices with eigenvalues u1, u2, -u2, -u1. Then C2.space() is the two dimensional vector spaces consisting of the linear functionals u1 and u2 on U. On the other hand $L i e (T) = R^{4}$ . A convenient way to see the restriction is to think of it as the adjoint of the map [u1,u2] -> [u1,u2,-u2,-u1], that is, [x0,x1,x2,x3] -> [x0-x3,x1-x2]. Hence we may encode the rule:

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

or simply:

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

Let us check that this agrees with the built-in rule:

Sage

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)

Python

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

Sage Live

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

Although this works, it is better to make the rule into an element of the BranchingRule class, as follows.

Sage

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)

Python

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

Sage Live

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

Maximal Subgroups and Branching Rules¶

Branching rules¶

What’s in a branching rule?¶