Bases: sage.structure.sage_object.SageObject
A class for branching rules.
In a branching rule R => S, returns the Cartan Type of the ambient group R.
EXAMPLES:
sage: branching_rule("A3","A2","levi").Rtype()
['A', 3]
In a branching rule R => S, returns the Cartan Type of the subgroup S.
EXAMPLES:
sage: branching_rule("A3","A2","levi").Stype()
['A', 2]
INPUT:
Returns the branched character.
EXAMPLES:
sage: G2=WeylCharacterRing("G2",style="coroots")
sage: chi=G2(1,1); chi.degree()
64
sage: b=G2.maximal_subgroup("A2"); b
extended branching rule G2 => A2
sage: b.branch(chi)
A2(0,1) + A2(1,0) + A2(0,2) + 2*A2(1,1) + A2(2,0) + A2(1,2) + A2(2,1)
sage: A2=WeylCharacterRing("A2",style="coroots"); A2
The Weyl Character Ring of Type A2 with Integer Ring coefficients
sage: chi.branch(A2,rule=b)
A2(0,1) + A2(1,0) + A2(0,2) + 2*A2(1,1) + A2(2,0) + A2(1,2) + A2(2,1)
Describes how extended roots restrict under self.
EXAMPLES:
sage: branching_rule("G2","A2","extended").describe()
3
O=<=O---O
1 2 0
G2~
root restrictions G2 => A2:
O---O
1 2
A2
0 => 2
2 => 1
For more detailed information use verbose=True
In this example, is the affine root, that is, the negative
of the highest root, for
. If
is printed, this
means that the i-th simple (or affine) root of the ambient
group restricts to the j-th simple root of the subgroup.
For reference the Dynkin diagrams are also printed. The
extended Dynkin diagram of the ambient group is printed if
the affine root restricts to a simple root. More information
is printed if the parameter
is true.
A branching rule describes the restriction of representations from
a Lie group or algebra to a subgroup
. See for example, R. C.
King, Branching rules for classical Lie groups using tensor and
spinor methods. J. Phys. A 8 (1975), 429-449, Howe, Tan and
Willenbring, Stable branching rules for classical symmetric pairs,
Trans. Amer. Math. Soc. 357 (2005), no. 4, 1601-1626, McKay and
Patera, Tables of Dimensions, Indices and Branching Rules for
Representations of Simple Lie Algebras (Marcel Dekker, 1981),
and Fauser, Jarvis, King and Wybourne, New branching rules induced
by plethysm. J. Phys. A 39 (2006), no. 11, 2611–2655. If
we will write
to denote the branching rule, which
is a homomorphism of WeylCharacterRings.
INPUT:
The BranchingRule class is a wrapper for functions
from the weight lattice of to the weight lattice of
.
An instance of this class encodes an embedding of
into
. The usual way to specify an embedding is to supply a
keyword, which tells Sage to use one of the built-in rules.
We will discuss these first.
To explain the predefined rules, we survey the most important branching rules. These may be classified into several cases, and once this is understood, the detailed classification can be read off from the Dynkin diagrams. Dynkin classified the maximal subgroups of Lie groups in Mat. Sbornik N.S. 30(72):349-462 (1952).
We will list give predefined rules that cover most cases where the branching rule is to a maximal subgroup. For convenience, we also give some branching rules to subgroups that are not maximal. For example, a Levi subgroup may or may not be maximal.
For example, there is a “levi” branching rule defined from (with
Cartan type
) to
(with Cartan type
), so
we may compute the branching rule as follows:
EXAMPLES:
sage: A3=WeylCharacterRing("A3",style="coroots")
sage: A2=WeylCharacterRing("A2",style="coroots")
sage: [A3(fw).branch(A2,rule="levi") for fw in A3.fundamental_weights()]
[A2(0,0) + A2(1,0), A2(0,1) + A2(1,0), A2(0,0) + A2(0,1)]
In this case the Levi branching rule is the default branching rule so we may omit the specification rule=”levi”.
If a subgroup is not maximal, you may specify a branching rule by finding a chain of intermediate subgroups. For this purpose, branching rules may be multiplied as in the following example.
EXAMPLES:
sage: A4=WeylCharacterRing("A4",style="coroots")
sage: A2=WeylCharacterRing("A2",style="coroots")
sage: br=branching_rule("A4","A3")*branching_rule("A3","A2")
sage: A4(1,0,0,0).branch(A2,rule=br)
2*A2(0,0) + A2(1,0)
You may try omitting the rule if it is “obvious”. Default rules are provided for the following cases:
The above default rules correspond to embedding the group
,
or
into the corresponding general
or special linear group by the standard representation. Default
rules are also specified for the following cases:
These correspond to the embedding of into
where
or
. Finally, the branching rule for the embedding of
a Levi subgroup is also implemented as a default rule.
EXAMPLES:
sage: A1 = WeylCharacterRing("A1", style="coroots")
sage: A2 = WeylCharacterRing("A2", style="coroots")
sage: D4 = WeylCharacterRing("D4", style="coroots")
sage: B3 = WeylCharacterRing("B3", style="coroots")
sage: B4 = WeylCharacterRing("B4", style="coroots")
sage: A6 = WeylCharacterRing("A6", style="coroots")
sage: A7 = WeylCharacterRing("A7", style="coroots")
sage: def try_default_rule(R,S): return [R(f).branch(S) for f in R.fundamental_weights()]
sage: try_default_rule(A2,A1)
[A1(0) + A1(1), A1(0) + A1(1)]
sage: try_default_rule(D4,B3)
[B3(0,0,0) + B3(1,0,0), B3(1,0,0) + B3(0,1,0), B3(0,0,1), B3(0,0,1)]
sage: try_default_rule(B4,D4)
[D4(0,0,0,0) + D4(1,0,0,0), D4(1,0,0,0) + D4(0,1,0,0),
D4(0,1,0,0) + D4(0,0,1,1), D4(0,0,1,0) + D4(0,0,0,1)]
sage: try_default_rule(A7,D4)
[D4(1,0,0,0), D4(0,1,0,0), D4(0,0,1,1), D4(0,0,2,0) + D4(0,0,0,2),
D4(0,0,1,1),
D4(0,1,0,0),
D4(1,0,0,0)]
sage: try_default_rule(A6,B3)
[B3(1,0,0), B3(0,1,0), B3(0,0,2), B3(0,0,2), B3(0,1,0), B3(1,0,0)]
If a default rule is not known, you may cue Sage as to what the Lie group embedding is by supplying a rule from the list of predefined rules. We will treat these next.
Levi Type
These can be read off from the Dynkin diagram. If removing a node from the Dynkin diagram produces another Dynkin diagram, there is a branching rule. A Levi subgroup may or may not be maximal. If it is maximal, there may or may not be a built-in branching rule for but you may obtain the Levi branching rule by first branching to a suitable maximal subgroup. For these rules use the option rule="levi":
Not all Levi subgroups are maximal subgroups. If the Levi is not
maximal there may or may not be a preprogrammed rule="levi" for
it. If there is not, the branching rule may still be obtained by going
through an intermediate subgroup that is maximal using rule=”extended”.
Thus the other Levi branching rule from corresponding to the
long root is available by first branching
then
.
Similarly the branching rules to the Levi subgroup:
may be obtained by first branching ,
or
.
EXAMPLES:
sage: A1 = WeylCharacterRing("A1")
sage: A2 = WeylCharacterRing("A2")
sage: A3 = WeylCharacterRing("A3")
sage: A4 = WeylCharacterRing("A4")
sage: A5 = WeylCharacterRing("A5")
sage: B2 = WeylCharacterRing("B2")
sage: B3 = WeylCharacterRing("B3")
sage: B4 = WeylCharacterRing("B4")
sage: C2 = WeylCharacterRing("C2")
sage: C3 = WeylCharacterRing("C3")
sage: D3 = WeylCharacterRing("D3")
sage: D4 = WeylCharacterRing("D4")
sage: G2 = WeylCharacterRing("G2")
sage: F4 = WeylCharacterRing("F4",style="coroots")
sage: E6=WeylCharacterRing("E6",style="coroots")
sage: E7=WeylCharacterRing("E7",style="coroots")
sage: D5=WeylCharacterRing("D5",style="coroots")
sage: D6=WeylCharacterRing("D6",style="coroots")
sage: [B3(w).branch(A2,rule="levi") for w in B3.fundamental_weights()]
[A2(0,0,0) + A2(1,0,0) + A2(0,0,-1),
A2(0,0,0) + A2(1,0,0) + A2(1,1,0) + A2(1,0,-1) + A2(0,-1,-1) + A2(0,0,-1),
A2(-1/2,-1/2,-1/2) + A2(1/2,-1/2,-1/2) + A2(1/2,1/2,-1/2) + A2(1/2,1/2,1/2)]
The last example must be understood as follows. The representation
of being branched is spin, which is not a representation of
but of its double cover
. The group
is
really GL(3) and the double cover of
induces a cover of
that is trivial over
but not over the center of
. The weight
lattice for this
consists of triples
of half integers
such that
and
are in
, and this is reflected in the
last decomposition.
sage: [C3(w).branch(A2,rule="levi") for w in C3.fundamental_weights()]
[A2(1,0,0) + A2(0,0,-1),
A2(1,1,0) + A2(1,0,-1) + A2(0,-1,-1),
A2(-1,-1,-1) + A2(1,-1,-1) + A2(1,1,-1) + A2(1,1,1)]
sage: [D4(w).branch(A3,rule="levi") for w in D4.fundamental_weights()]
[A3(1,0,0,0) + A3(0,0,0,-1),
A3(0,0,0,0) + A3(1,1,0,0) + A3(1,0,0,-1) + A3(0,0,-1,-1),
A3(1/2,-1/2,-1/2,-1/2) + A3(1/2,1/2,1/2,-1/2),
A3(-1/2,-1/2,-1/2,-1/2) + A3(1/2,1/2,-1/2,-1/2) + A3(1/2,1/2,1/2,1/2)]
sage: [B3(w).branch(B2,rule="levi") for w in B3.fundamental_weights()]
[2*B2(0,0) + B2(1,0), B2(0,0) + 2*B2(1,0) + B2(1,1), 2*B2(1/2,1/2)]
sage: C3 = WeylCharacterRing(['C',3])
sage: [C3(w).branch(C2,rule="levi") for w in C3.fundamental_weights()]
[2*C2(0,0) + C2(1,0),
C2(0,0) + 2*C2(1,0) + C2(1,1),
C2(1,0) + 2*C2(1,1)]
sage: [D5(w).branch(D4,rule="levi") for w in D5.fundamental_weights()]
[2*D4(0,0,0,0) + D4(1,0,0,0),
D4(0,0,0,0) + 2*D4(1,0,0,0) + D4(1,1,0,0),
D4(1,0,0,0) + 2*D4(1,1,0,0) + D4(1,1,1,0),
D4(1/2,1/2,1/2,-1/2) + D4(1/2,1/2,1/2,1/2),
D4(1/2,1/2,1/2,-1/2) + D4(1/2,1/2,1/2,1/2)]
sage: G2(1,0,-1).branch(A1,rule="levi")
A1(1,0) + A1(1,-1) + A1(0,-1)
sage: E6=WeylCharacterRing("E6",style="coroots")
sage: D5=WeylCharacterRing("D5",style="coroots")
sage: fw = E6.fundamental_weights()
sage: [E6(fw[i]).branch(D5,rule="levi") for i in [1,2,6]]
[D5(0,0,0,0,0) + D5(0,0,0,0,1) + D5(1,0,0,0,0),
D5(0,0,0,0,0) + D5(0,0,0,1,0) + D5(0,0,0,0,1) + D5(0,1,0,0,0),
D5(0,0,0,0,0) + D5(0,0,0,1,0) + D5(1,0,0,0,0)]
sage: E7=WeylCharacterRing("E7",style="coroots")
sage: A3xA3xA1=WeylCharacterRing("A3xA3xA1",style="coroots")
sage: E7(1,0,0,0,0,0,0).branch(A3xA3xA1,rule="extended") # long time (0.7s)
A3xA3xA1(0,0,1,0,0,1,1) + A3xA3xA1(0,1,0,0,1,0,0) + A3xA3xA1(1,0,0,1,0,0,1) +
A3xA3xA1(1,0,1,0,0,0,0) + A3xA3xA1(0,0,0,1,0,1,0) + A3xA3xA1(0,0,0,0,0,0,2)
sage: fw = E7.fundamental_weights()
sage: [E7(fw[i]).branch(D6,rule="levi") for i in [1,2,7]] # long time (0.3s)
[3*D6(0,0,0,0,0,0) + 2*D6(0,0,0,0,1,0) + D6(0,1,0,0,0,0),
3*D6(0,0,0,0,0,1) + 2*D6(1,0,0,0,0,0) + 2*D6(0,0,1,0,0,0) + D6(1,0,0,0,1,0),
D6(0,0,0,0,0,1) + 2*D6(1,0,0,0,0,0)]
sage: D7=WeylCharacterRing("D7",style="coroots")
sage: E8=WeylCharacterRing("E8",style="coroots")
sage: D7=WeylCharacterRing("D7",style="coroots")
sage: E8(1,0,0,0,0,0,0,0).branch(D7,rule="levi") # long time (7s)
3*D7(0,0,0,0,0,0,0) + 2*D7(0,0,0,0,0,1,0) + 2*D7(0,0,0,0,0,0,1) + 2*D7(1,0,0,0,0,0,0)
+ D7(0,1,0,0,0,0,0) + 2*D7(0,0,1,0,0,0,0) + D7(0,0,0,1,0,0,0) + D7(1,0,0,0,0,1,0) + D7(1,0,0,0,0,0,1) + D7(2,0,0,0,0,0,0)
sage: E8(0,0,0,0,0,0,0,1).branch(D7,rule="levi") # long time (0.6s)
D7(0,0,0,0,0,0,0) + D7(0,0,0,0,0,1,0) + D7(0,0,0,0,0,0,1) + 2*D7(1,0,0,0,0,0,0) + D7(0,1,0,0,0,0,0)
sage: [F4(fw).branch(B3,rule="levi") for fw in F4.fundamental_weights()] # long time (1s)
[B3(0,0,0) + 2*B3(1/2,1/2,1/2) + 2*B3(1,0,0) + B3(1,1,0),
B3(0,0,0) + 6*B3(1/2,1/2,1/2) + 5*B3(1,0,0) + 7*B3(1,1,0) + 3*B3(1,1,1)
+ 6*B3(3/2,1/2,1/2) + 2*B3(3/2,3/2,1/2) + B3(2,0,0) + 2*B3(2,1,0) + B3(2,1,1),
3*B3(0,0,0) + 6*B3(1/2,1/2,1/2) + 4*B3(1,0,0) + 3*B3(1,1,0) + B3(1,1,1) + 2*B3(3/2,1/2,1/2),
3*B3(0,0,0) + 2*B3(1/2,1/2,1/2) + B3(1,0,0)]
sage: [F4(fw).branch(C3,rule="levi") for fw in F4.fundamental_weights()] # long time (1s)
[3*C3(0,0,0) + 2*C3(1,1,1) + C3(2,0,0),
3*C3(0,0,0) + 6*C3(1,1,1) + 4*C3(2,0,0) + 2*C3(2,1,0) + 3*C3(2,2,0) + C3(2,2,2) + C3(3,1,0) + 2*C3(3,1,1),
2*C3(1,0,0) + 3*C3(1,1,0) + C3(2,0,0) + 2*C3(2,1,0) + C3(2,1,1),
2*C3(1,0,0) + C3(1,1,0)]
sage: A1xA1 = WeylCharacterRing("A1xA1")
sage: [A3(hwv).branch(A1xA1,rule="levi") for hwv in A3.fundamental_weights()]
[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)]
sage: A1xB1=WeylCharacterRing("A1xB1",style="coroots")
sage: [B3(x).branch(A1xB1,rule="levi") for x in B3.fundamental_weights()]
[2*A1xB1(1,0) + A1xB1(0,2),
3*A1xB1(0,0) + 2*A1xB1(1,2) + A1xB1(2,0) + A1xB1(0,2),
A1xB1(1,1) + 2*A1xB1(0,1)]
Automorphic Type
If the Dynkin diagram has a symmetry, then there
is an automorphism that is a special case of a branching rule.
There is also an exotic “triality” automorphism of having order 3.
Use rule="automorphic" (or for
rule="triality"):
EXAMPLES:
sage: [A3(chi).branch(A3,rule="automorphic") for chi in A3.fundamental_weights()]
[A3(0,0,0,-1), A3(0,0,-1,-1), A3(0,-1,-1,-1)]
sage: [D4(chi).branch(D4,rule="automorphic") for chi in D4.fundamental_weights()]
[D4(1,0,0,0), D4(1,1,0,0), D4(1/2,1/2,1/2,1/2), D4(1/2,1/2,1/2,-1/2)]
Here is an example with triality:
sage: [D4(chi).branch(D4,rule="triality") for chi in D4.fundamental_weights()]
[D4(1/2,1/2,1/2,-1/2), D4(1,1,0,0), D4(1/2,1/2,1/2,1/2), D4(1,0,0,0)]
Symmetric Type
Related to the automorphic type, when admits
an outer automorphism (usually of degree 2) we may consider
the branching rule to the isotropy subgroup
. Outer
automorphisms correspond to symmetries of the Dynkin diagram.
For such isotropy subgroups use rule="symmetric".
We may thus obtain the following branching rules.
The last branching rule, is not to a maximal subgroup
since
, but it is included for convenience.
In some cases, two outer automorphisms that differ by an
inner automorphism may have different fixed subgroups.
Thus, while the Dynkin diagram of has a single
involutory automorphism, there are two involutions
of the group (differing by an inner automorphism) with
fixed subgroups
and
. Similarly
, of Cartan type
, has subgroups
and
, both fixed subgroups of outer
automorphisms that differ from each other by an inner
automorphism.
In many cases the Dynkin diagram of can be obtained by
folding the Dynkin diagram of
.
EXAMPLES:
sage: [w.branch(B2,rule="symmetric") for w in [A4(1,0,0,0,0),A4(1,1,0,0,0),A4(1,1,1,0,0),A4(2,0,0,0,0)]]
[B2(1,0), B2(1,1), B2(1,1), B2(0,0) + B2(2,0)]
sage: [A5(w).branch(C3,rule="symmetric") for w in A5.fundamental_weights()]
[C3(1,0,0), C3(0,0,0) + C3(1,1,0), C3(1,0,0) + C3(1,1,1), C3(0,0,0) + C3(1,1,0), C3(1,0,0)]
sage: [A5(w).branch(D3,rule="symmetric") for w in A5.fundamental_weights()]
[D3(1,0,0), D3(1,1,0), D3(1,1,-1) + D3(1,1,1), D3(1,1,0), D3(1,0,0)]
sage: [D4(x).branch(B3,rule="symmetric") for x in D4.fundamental_weights()]
[B3(0,0,0) + B3(1,0,0), B3(1,0,0) + B3(1,1,0), B3(1/2,1/2,1/2), B3(1/2,1/2,1/2)]
sage: [D4(x).branch(G2,rule="symmetric") for x in D4.fundamental_weights()]
[G2(0,0,0) + G2(1,0,-1), 2*G2(1,0,-1) + G2(2,-1,-1), G2(0,0,0) + G2(1,0,-1), G2(0,0,0) + G2(1,0,-1)]
sage: [E6(fw).branch(F4,rule="symmetric") for fw in E6.fundamental_weights()] # long time (4s)
[F4(0,0,0,0) + F4(0,0,0,1),
F4(0,0,0,1) + F4(1,0,0,0),
F4(0,0,0,1) + F4(1,0,0,0) + F4(0,0,1,0),
F4(1,0,0,0) + 2*F4(0,0,1,0) + F4(1,0,0,1) + F4(0,1,0,0),
F4(0,0,0,1) + F4(1,0,0,0) + F4(0,0,1,0),
F4(0,0,0,0) + F4(0,0,0,1)]
sage: E6=WeylCharacterRing("E6",style="coroots")
sage: C4=WeylCharacterRing("C4",style="coroots")
sage: chi = E6(1,0,0,0,0,0); chi.degree()
27
sage: chi.branch(C4,rule="symmetric")
C4(0,1,0,0)
Extended Type
If removing a node from the extended Dynkin diagram
results in a Dynkin diagram, then there is a branching rule. Use
rule="extended" for these. We will also use this classification
for some rules that are not of this type, mainly involving type ,
such as
.
Here is the extended Dynkin diagram for :
0 6
O O
| |
| |
O---O---O---O---O
1 2 3 4 6
Removing the node 3 results in an embedding .
This corresponds to the embedding
, and
is of extended type. On the other hand the embedding
(e.g.
) cannot be explained this way
but for uniformity is implemented under rule="extended".
The following rules are implemented as special cases of rule="extended":
Note that has only a limited number of representations of
reasonably low degree.
EXAMPLES:
sage: [B3(x).branch(D3,rule="extended") for x in B3.fundamental_weights()]
[D3(0,0,0) + D3(1,0,0),
D3(1,0,0) + D3(1,1,0),
D3(1/2,1/2,-1/2) + D3(1/2,1/2,1/2)]
sage: [G2(w).branch(A2, rule="extended") for w in G2.fundamental_weights()]
[A2(0,0,0) + A2(1/3,1/3,-2/3) + A2(2/3,-1/3,-1/3),
A2(1/3,1/3,-2/3) + A2(2/3,-1/3,-1/3) + A2(1,0,-1)]
sage: [F4(fw).branch(B4,rule="extended") for fw in F4.fundamental_weights()] # long time (2s)
[B4(1/2,1/2,1/2,1/2) + B4(1,1,0,0),
B4(1,1,0,0) + B4(1,1,1,0) + B4(3/2,1/2,1/2,1/2) + B4(3/2,3/2,1/2,1/2) + B4(2,1,1,0),
B4(1/2,1/2,1/2,1/2) + B4(1,0,0,0) + B4(1,1,0,0) + B4(1,1,1,0) + B4(3/2,1/2,1/2,1/2),
B4(0,0,0,0) + B4(1/2,1/2,1/2,1/2) + B4(1,0,0,0)]
sage: E6 = WeylCharacterRing("E6", style="coroots")
sage: A2xA2xA2=WeylCharacterRing("A2xA2xA2",style="coroots")
sage: A5xA1=WeylCharacterRing("A5xA1",style="coroots")
sage: G2 = WeylCharacterRing("G2", style="coroots")
sage: A1xA1 = WeylCharacterRing("A1xA1", style="coroots")
sage: F4 = WeylCharacterRing("F4",style="coroots")
sage: A3xA1 = WeylCharacterRing("A3xA1", style="coroots")
sage: A2xA2 = WeylCharacterRing("A2xA2", style="coroots")
sage: A1xC3 = WeylCharacterRing("A1xC3",style="coroots")
sage: E6(1,0,0,0,0,0).branch(A5xA1,rule="extended") # (0.7s)
A5xA1(0,0,0,1,0,0) + A5xA1(1,0,0,0,0,1)
sage: E6(1,0,0,0,0,0).branch(A2xA2xA2, rule="extended") # (0.7s)
A2xA2xA2(0,1,1,0,0,0) + A2xA2xA2(1,0,0,0,0,1) + A2xA2xA2(0,0,0,1,1,0)
sage: E7 = WeylCharacterRing("E7",style="coroots")
sage: A7 = WeylCharacterRing("A7",style="coroots")
sage: E7(1,0,0,0,0,0,0).branch(A7,rule="extended")
A7(0,0,0,1,0,0,0) + A7(1,0,0,0,0,0,1)
sage: D6xA1 = WeylCharacterRing("D6xA1",style="coroots")
sage: E7(1,0,0,0,0,0,0).branch(D6xA1,rule="extended")
D6xA1(0,0,0,0,1,0,1) + D6xA1(0,1,0,0,0,0,0) + D6xA1(0,0,0,0,0,0,2)
sage: A5xA2 =WeylCharacterRing("A5xA2",style="coroots")
sage: E7(1,0,0,0,0,0,0).branch(A5xA2,rule="extended")
A5xA2(0,0,0,1,0,1,0) + A5xA2(0,1,0,0,0,0,1) + A5xA2(1,0,0,0,1,0,0) + A5xA2(0,0,0,0,0,1,1)
sage: E8 = WeylCharacterRing("E8",style="coroots")
sage: D8 = WeylCharacterRing("D8",style="coroots")
sage: A8 = WeylCharacterRing("A8",style="coroots")
sage: E8(0,0,0,0,0,0,0,1).branch(D8,rule="extended") # long time (0.56s)
D8(0,0,0,0,0,0,1,0) + D8(0,1,0,0,0,0,0,0)
sage: E8(0,0,0,0,0,0,0,1).branch(A8,rule="extended") # long time (0.73s)
A8(0,0,0,0,0,1,0,0) + A8(0,0,1,0,0,0,0,0) + A8(1,0,0,0,0,0,0,1)
sage: F4(1,0,0,0).branch(A1xC3,rule="extended") # (0.05s)
A1xC3(1,0,0,1) + A1xC3(2,0,0,0) + A1xC3(0,2,0,0)
sage: G2(0,1).branch(A1xA1, rule="extended")
A1xA1(2,0) + A1xA1(3,1) + A1xA1(0,2)
sage: F4(0,0,0,1).branch(A2xA2, rule="extended") # (0.4s)
A2xA2(0,1,0,1) + A2xA2(1,0,1,0) + A2xA2(0,0,1,1)
sage: F4(0,0,0,1).branch(A3xA1,rule="extended") # (0.34s)
A3xA1(0,0,0,0) + A3xA1(0,0,1,1) + A3xA1(0,1,0,0) + A3xA1(1,0,0,1) + A3xA1(0,0,0,2)
sage: D4=WeylCharacterRing("D4",style="coroots")
sage: D2xD2=WeylCharacterRing("D2xD2",style="coroots") # We get D4 => A1xA1xA1xA1 by remembering that A1xA1 = D2.
sage: [D4(fw).branch(D2xD2, rule="extended") for fw in D4.fundamental_weights()]
[D2xD2(1,1,0,0) + D2xD2(0,0,1,1),
D2xD2(2,0,0,0) + D2xD2(0,2,0,0) + D2xD2(1,1,1,1) + D2xD2(0,0,2,0) + D2xD2(0,0,0,2),
D2xD2(1,0,0,1) + D2xD2(0,1,1,0),
D2xD2(1,0,1,0) + D2xD2(0,1,0,1)]
Orthogonal Sum
Using rule="orthogonal_sum", for ,
you can get any branching rule
where is type
for
or
for
and
is type
. In some cases these are also of
extended type, as in the case
discussed above.
But in other cases, for example
, they are not
of extended type.
Tensor
There are branching rules:
corresponding to the tensor product homomorphism. For type
, the homomorphism is
. For the
classical types, the relevant fact is that if
are
orthogonal or symplectic spaces, that is, spaces endowed
with symmetric or skew-symmetric bilinear forms, then
is also an orthogonal space (if
and
are both
orthogonal or both symplectic) or symplectic (if one of
and
is orthogonal and the other symplectic).
The corresponding branching rules are obtained using rule="tensor".
EXAMPLES:
sage: A5=WeylCharacterRing("A5", style="coroots")
sage: A2xA1=WeylCharacterRing("A2xA1", style="coroots")
sage: [A5(hwv).branch(A2xA1, rule="tensor") for hwv in A5.fundamental_weights()]
[A2xA1(1,0,1),
A2xA1(0,1,2) + A2xA1(2,0,0),
A2xA1(1,1,1) + A2xA1(0,0,3),
A2xA1(1,0,2) + A2xA1(0,2,0),
A2xA1(0,1,1)]
sage: B4=WeylCharacterRing("B4",style="coroots")
sage: B1xB1=WeylCharacterRing("B1xB1",style="coroots")
sage: [B4(f).branch(B1xB1,rule="tensor") for f in B4.fundamental_weights()]
[B1xB1(2,2),
B1xB1(2,0) + B1xB1(2,4) + B1xB1(4,2) + B1xB1(0,2),
B1xB1(2,0) + B1xB1(2,2) + B1xB1(2,4) + B1xB1(4,2) + B1xB1(4,4) + B1xB1(6,0) + B1xB1(0,2) + B1xB1(0,6),
B1xB1(1,3) + B1xB1(3,1)]
sage: D4=WeylCharacterRing("D4",style="coroots")
sage: C2xC1=WeylCharacterRing("C2xC1",style="coroots")
sage: [D4(f).branch(C2xC1,rule="tensor") for f in D4.fundamental_weights()]
[C2xC1(1,0,1),
C2xC1(0,1,2) + C2xC1(2,0,0) + C2xC1(0,0,2),
C2xC1(1,0,1),
C2xC1(0,1,0) + C2xC1(0,0,2)]
sage: C3=WeylCharacterRing("C3",style="coroots")
sage: B1xC1=WeylCharacterRing("B1xC1",style="coroots")
sage: [C3(f).branch(B1xC1,rule="tensor") for f in C3.fundamental_weights()]
[B1xC1(2,1), B1xC1(2,2) + B1xC1(4,0), B1xC1(4,1) + B1xC1(0,3)]
Symmetric Power
The -th symmetric and exterior power homomorphisms map
The corresponding branching rules are not implemented but a special
case is. The -th symmetric power homomorphism
has its image inside of
if
and inside of
if
. Hence there are branching rules:
and these may be obtained using the rule “symmetric_power”.
EXAMPLES:
sage: A1=WeylCharacterRing("A1",style="coroots")
sage: B3=WeylCharacterRing("B3",style="coroots")
sage: C3=WeylCharacterRing("C3",style="coroots")
sage: [B3(fw).branch(A1,rule="symmetric_power") for fw in B3.fundamental_weights()]
[A1(6), A1(2) + A1(6) + A1(10), A1(0) + A1(6)]
sage: [C3(fw).branch(A1,rule="symmetric_power") for fw in C3.fundamental_weights()]
[A1(5), A1(4) + A1(8), A1(3) + A1(9)]
Miscellaneous
Use rule="miscellaneous" for the following embeddings of maximal subgroups, all involving exceptional groups.
Except for those embeddings available by rule="extended", these
are the only embeddings of these groups as maximal subgroups.
There may be other embeddings besides these. For example,
there are other more obvious embeddings of and
into
.
However the embeddings in this table are characterized as embeddings
as maximal subgroups. Regarding the embeddings of
and
in
, the embeddings in question may be characterized by the condition that the
27-dimensional representations of
restrict irreducibly to
or
. Since
has a subgroup isomorphic to
, it is worth
mentioning that the composite branching rules:
branching_rule("E6","G2","miscellaneous")*branching_rule("G2","A2","extended")
branching_rule("E6","A2","miscellaneous")
are distinct.
These embeddings are described more completely (with references to the literature) in the thematic tutorial at:
http://www.sagemath.org/doc/thematic_tutorials/lie.html
EXAMPLES:
sage: G2 = WeylCharacterRing("G2")
sage: [fw1, fw2, fw3] = B3.fundamental_weights()
sage: B3(fw1+fw3).branch(G2, rule="miscellaneous")
G2(1,0,-1) + G2(2,-1,-1) + G2(2,0,-2)
sage: E6 = WeylCharacterRing("E6",style="coroots")
sage: G2 = WeylCharacterRing("G2",style="coroots")
sage: E6(1,0,0,0,0,0).branch(G2,"miscellaneous")
G2(2,0)
sage: A2=WeylCharacterRing("A2",style="coroots")
sage: E6(1,0,0,0,0,0).branch(A2,rule="miscellaneous")
A2(2,2)
sage: E6(0,1,0,0,0,0).branch(A2,rule="miscellaneous")
A2(1,1) + A2(1,4) + A2(4,1)
sage: E6(0,0,0,0,0,2).branch(G2,"miscellaneous") # long time (0.59s)
G2(0,0) + G2(2,0) + G2(1,1) + G2(0,2) + G2(4,0)
sage: F4=WeylCharacterRing("F4",style="coroots")
sage: G2xA1=WeylCharacterRing("G2xA1",style="coroots")
sage: F4(0,0,1,0).branch(G2xA1,rule="miscellaneous")
G2xA1(1,0,0) + G2xA1(1,0,2) + G2xA1(1,0,4) + G2xA1(1,0,6) + G2xA1(0,1,4) + G2xA1(2,0,2) + G2xA1(0,0,2) + G2xA1(0,0,6)
sage: E6 = WeylCharacterRing("E6",style="coroots")
sage: A2xG2 = WeylCharacterRing("A2xG2",style="coroots")
sage: E6(1,0,0,0,0,0).branch(A2xG2,rule="miscellaneous")
A2xG2(0,1,1,0) + A2xG2(2,0,0,0)
sage: E7=WeylCharacterRing("E7",style="coroots")
sage: G2xC3=WeylCharacterRing("G2xC3",style="coroots")
sage: E7(0,1,0,0,0,0,0).branch(G2xC3,rule="miscellaneous") # long time (1.84s)
G2xC3(1,0,1,0,0) + G2xC3(1,0,1,1,0) + G2xC3(0,1,0,0,1) + G2xC3(2,0,1,0,0) + G2xC3(0,0,1,1,0)
sage: F4xA1=WeylCharacterRing("F4xA1",style="coroots")
sage: E7(0,0,0,0,0,0,1).branch(F4xA1,"miscellaneous")
F4xA1(0,0,0,1,1) + F4xA1(0,0,0,0,3)
sage: A1xA1=WeylCharacterRing("A1xA1",style="coroots")
sage: E7(0,0,0,0,0,0,1).branch(A1xA1,rule="miscellaneous")
A1xA1(2,5) + A1xA1(4,1) + A1xA1(6,3)
sage: A2=WeylCharacterRing("A2",style="coroots")
sage: E7(0,0,0,0,0,0,1).branch(A2,rule="miscellaneous")
A2(0,6) + A2(6,0)
sage: G2xA1=WeylCharacterRing("G2xA1",style="coroots")
sage: E7(1,0,0,0,0,0,0).branch(G2xA1,rule="miscellaneous")
G2xA1(1,0,4) + G2xA1(0,1,0) + G2xA1(2,0,2) + G2xA1(0,0,2)
sage: E8 = WeylCharacterRing("E8",style="coroots")
sage: G2xF4 = WeylCharacterRing("G2xF4",style="coroots")
sage: E8(0,0,0,0,0,0,0,1).branch(G2xF4,rule="miscellaneous") # long time (0.76s)
G2xF4(1,0,0,0,0,1) + G2xF4(0,1,0,0,0,0) + G2xF4(0,0,1,0,0,0)
sage: E8=WeylCharacterRing("E8",style="coroots")
sage: A1xA2=WeylCharacterRing("A1xA2",style="coroots")
sage: E8(0,0,0,0,0,0,0,1).branch(A1xA2,rule="miscellaneous") # long time (0.76s)
A1xA2(2,0,0) + A1xA2(2,2,2) + A1xA2(4,0,3) + A1xA2(4,3,0) + A1xA2(6,1,1) + A1xA2(0,1,1)
sage: B2=WeylCharacterRing("B2",style="coroots")
sage: E8(0,0,0,0,0,0,0,1).branch(B2,rule="miscellaneous") # long time (0.53s)
B2(0,2) + B2(0,6) + B2(3,2)
A1 maximal subgroups of exceptional groups
There are seven cases where the exceptional group ,
,
or
contains a maximal subgroup of type
.
These are tabulated in Theorem 1 of Testerman,
The construction of the maximal A1’s in the exceptional algebraic groups,
Proc. Amer. Math. Soc. 116 (1992), no. 3, 635-644. The
names of these branching rules are roman numerals referring
to the seven cases of her Theorem 1. Use these branching
rules as in the following examples.
EXAMPLES:
sage: A1=WeylCharacterRing("A1",style="coroots")
sage: G2=WeylCharacterRing("G2",style="coroots")
sage: F4=WeylCharacterRing("F4",style="coroots")
sage: E7=WeylCharacterRing("E7",style="coroots")
sage: E8=WeylCharacterRing("E8",style="coroots")
sage: [G2(f).branch(A1,rule="i") for f in G2.fundamental_weights()]
[A1(6), A1(2) + A1(10)]
sage: F4(1,0,0,0).branch(A1,rule="ii")
A1(2) + A1(10) + A1(14) + A1(22)
sage: E7(0,0,0,0,0,0,1).branch(A1,rule="iii")
A1(9) + A1(17) + A1(27)
sage: E7(0,0,0,0,0,0,1).branch(A1,rule="iv")
A1(5) + A1(11) + A1(15) + A1(21)
sage: E8(0,0,0,0,0,0,0,1).branch(A1,rule="v") # long time (0.6s)
A1(2) + A1(14) + A1(22) + A1(26) + A1(34) + A1(38) + A1(46) + A1(58)
sage: E8(0,0,0,0,0,0,0,1).branch(A1,rule="vi") # long time (0.6s)
A1(2) + A1(10) + A1(14) + A1(18) + A1(22) + A1(26) + A1(28) + A1(34) + A1(38) + A1(46)
sage: E8(0,0,0,0,0,0,0,1).branch(A1,rule="vii") # long time (0.6s)
A1(2) + A1(6) + A1(10) + A1(14) + A1(16) + A1(18) + 2*A1(22) + A1(26) + A1(28) + A1(34) + A1(38)
Branching Rules From Plethysms
Nearly all branching rules where
is of type
,
,
or
are covered by the preceding rules. The function
branching_rule_from_plethysm() covers the remaining cases.
This is a general rule that includes any branching rule
from types ,
,
, or
as a special case. Thus it could be
used in place of the above rules and would give the same
results. However it is most useful when branching from
to a maximal subgroup
such that
.
We consider a homomorphism where
is one of
,
,
or
. The function
branching_rule_from_plethysm() produces the corresponding
branching rule. The main ingredient is the character
of the representation of
that is the homomorphism
to
,
or
.
This rule is so powerful that it contains the other
rules implemented above as special cases. First let
us consider the symmetric fifth power representation
of .
sage: A1=WeylCharacterRing("A1",style="coroots")
sage: chi=A1([5])
sage: chi.degree()
6
sage: chi.frobenius_schur_indicator()
-1
This confirms that the character has degree 6 and
is symplectic, so it corresponds to a homomorphism
, and there is a corresponding
branching rule
.
sage: C3 = WeylCharacterRing("C3",style="coroots")
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)]
This is identical to the results we would obtain using rule="symmetric_power". The next example gives a branching not available by other standard rules.
sage: G2 = WeylCharacterRing("G2",style="coroots")
sage: D7 = WeylCharacterRing("D7",style="coroots")
sage: ad=G2(0,1); ad.degree(); ad.frobenius_schur_indicator()
14
1
sage: spin = D7(0,0,0,0,0,1,0); spin.degree()
64
sage: spin.branch(G2, rule=branching_rule_from_plethysm(ad, "D7"))
G2(1,1)
We have confirmed that the adjoint representation of
gives a homomorphism into
, and that the pullback
of the one of the two 64 dimensional spin representations
to
is an irreducible representation of
.
We do not actually have to create the character or its parent WeylCharacterRing to create the branching rule:
sage: b = branching_rule("C7","C3(0,0,1)","plethysm"); b
plethysm (along C3(0,0,1)) branching rule C7 => C3
Isomorphic Type
Although not usually referred to as a branching rule, the effects of the accidental isomorphisms may be handled using rule="isomorphic":
EXAMPLES:
sage: B2 = WeylCharacterRing("B2")
sage: C2 = WeylCharacterRing("C2")
sage: [B2(x).branch(C2, rule="isomorphic") for x in B2.fundamental_weights()]
[C2(1,1), C2(1,0)]
sage: [C2(x).branch(B2, rule="isomorphic") for x in C2.fundamental_weights()]
[B2(1/2,1/2), B2(1,0)]
sage: D3 = WeylCharacterRing("D3")
sage: A3 = WeylCharacterRing("A3")
sage: [A3(x).branch(D3,rule="isomorphic") for x in A3.fundamental_weights()]
[D3(1/2,1/2,1/2), D3(1,0,0), D3(1/2,1/2,-1/2)]
sage: [D3(x).branch(A3,rule="isomorphic") for x in D3.fundamental_weights()]
[A3(1/2,1/2,-1/2,-1/2), A3(1/4,1/4,1/4,-3/4), A3(3/4,-1/4,-1/4,-1/4)]
Here can be understood as a representation of
.
The weights
and
represent the same
representation of
- though not of
- since
is the same as
tensored with
. So as a representation of
,
A3(1/4,1/4,1/4,-3/4) is the same as A3(1,1,1,0). The exterior
square representation
admits an invariant symmetric
bilinear form, so is a representation
that lifts to
an isomorphism
. Conversely, there are two
isomorphisms
, of which we’ve selected one.
In cases like this you might prefer style="coroots":
sage: A3 = WeylCharacterRing("A3",style="coroots")
sage: D3 = WeylCharacterRing("D3",style="coroots")
sage: [D3(fw) for fw in D3.fundamental_weights()]
[D3(1,0,0), D3(0,1,0), D3(0,0,1)]
sage: [D3(fw).branch(A3,rule="isomorphic") for fw in D3.fundamental_weights()]
[A3(0,1,0), A3(0,0,1), A3(1,0,0)]
sage: D2 = WeylCharacterRing("D2", style="coroots")
sage: A1xA1 = WeylCharacterRing("A1xA1", style="coroots")
sage: [D2(fw).branch(A1xA1,rule="isomorphic") for fw in D2.fundamental_weights()]
[A1xA1(1,0), A1xA1(0,1)]
Branching From a Reducible WeylCharacterRing
If the Cartan Type of R is reducible, we may project a character onto any of the components, or any combination of components. The rule to project on the first component is specified by the string "proj1", the rule to project on the second component is "proj2". To project on the first and third components, use ``"proj13" and so on.
EXAMPLES:
sage: A2xG2=WeylCharacterRing("A2xG2",style="coroots")
sage: A2=WeylCharacterRing("A2",style="coroots")
sage: G2=WeylCharacterRing("G2",style="coroots")
sage: A2xG2(1,0,1,0).branch(A2,rule="proj1")
7*A2(1,0)
sage: A2xG2(1,0,1,0).branch(G2,rule="proj2")
3*G2(1,0)
sage: A2xA2xG2=WeylCharacterRing("A2xA2xG2",style="coroots")
sage: A2xA2xG2(0,1,1,1,0,1).branch(A2xG2,rule="proj13")
8*A2xG2(0,1,0,1)
A more general way of specifying a branching rule from a reducible type is
to supply a list of rules, one component rule for each
component type in the root system. In the following example, we branch the
fundamental representations of down to
through the intermediate group
. We use
multiplicative notation to compose the branching rules. There is no need
to construct the intermediate WeylCharacterRing with type
.
EXAMPLES:
sage: D4 = WeylCharacterRing("D4",style="coroots")
sage: A1xA1xA1xA1 = WeylCharacterRing("A1xA1xA1xA1",style="coroots")
sage: b = branching_rule("D2","A1xA1","isomorphic")
sage: br = branching_rule("D4","D2xD2","extended")*branching_rule("D2xD2","A1xA1xA1xA1",[b,b])
sage: [D4(fw).branch(A1xA1xA1xA1,rule=br) for fw in D4.fundamental_weights()]
[A1xA1xA1xA1(1,1,0,0) + A1xA1xA1xA1(0,0,1,1),
A1xA1xA1xA1(1,1,1,1) + A1xA1xA1xA1(2,0,0,0) + A1xA1xA1xA1(0,2,0,0) + A1xA1xA1xA1(0,0,2,0) + A1xA1xA1xA1(0,0,0,2),
A1xA1xA1xA1(1,0,0,1) + A1xA1xA1xA1(0,1,1,0),
A1xA1xA1xA1(1,0,1,0) + A1xA1xA1xA1(0,1,0,1)]
In the list of rules to be supplied in branching from a reducible root
system, we may use two key words “omit” and “identity”. The term “omit”
means that we omit one factor, projecting onto the remaining factors.
The term “identity” is supplied when the irreducible factor Cartan Types
of both the target and the source are the same, and the component
branching rule is to be the identity map. For example, we have
projection maps from to
and
, and
the corresponding branching may be accomplished as follows. In
this example the same could be accomplished using rule="proj2".
EXAMPLES:
sage: A3xA2=WeylCharacterRing("A3xA2",style="coroots")
sage: A3=WeylCharacterRing("A3",style="coroots")
sage: chi = A3xA2(0,1,0,1,0)
sage: chi.branch(A3,rule=["identity","omit"])
3*A3(0,1,0)
sage: A2=WeylCharacterRing("A2",style="coroots")
sage: chi.branch(A2,rule=["omit","identity"])
6*A2(1,0)
Yet another way of branching from a reducible root system with repeated Cartan types is to embed along the diagonal. The branching rule is equivalent to the tensor product, as the example shows:
sage: G2=WeylCharacterRing("G2",style="coroots")
sage: G2xG2=WeylCharacterRing("G2xG2",style="coroots")
sage: G2=WeylCharacterRing("G2",style="coroots")
sage: G2xG2(1,0,0,1).branch(G2,rule="diagonal")
G2(1,0) + G2(2,0) + G2(1,1)
sage: G2xG2(1,0,0,1).branch(G2,rule="diagonal") == G2(1,0)*G2(0,1)
True
Writing Your Own (Branching) Rules
Suppose you want to branch from a group to a subgroup
.
Arrange the embedding so that a Cartan subalgebra
of
is
contained in a Cartan subalgebra
of
. There is thus
a mapping from the weight spaces
.
Two embeddings will produce identical branching rules if they
differ by an element of the Weyl group of
.
The rule is this map , which is G.space(), to
, which is H.space(),
which you may implement as a function. As an example, let
us consider how to implement the branching rule
.
Here
embedded as a subgroup in
. The
Cartan subalgebra
consists of diagonal matrices with
eigenvalues
. The C2.space() is the
two dimensional vector spaces consisting of the linear
functionals
and
on
. On the other hand
is
. A convenient way to see the restriction is to
think of it as the adjoint of the map
,
that is,
. Hence we may
encode the rule as follows:
def rule(x):
return [x[0]-x[3],x[1]-x[2]]
or simply:
rule = lambda x : [x[0]-x[3],x[1]-x[2]]
We may now make and use the branching rule as follows.
EXAMPLES:
sage: br = BranchingRule("A3", "C2", lambda x : [x[0]-x[3],x[1]-x[2]], "homemade"); br
homemade branching rule A3 => C2
sage: [A3,C2]=[WeylCharacterRing(x,style="coroots") for x in ["A3","C2"]]
sage: A3(0,1,0).branch(C2,rule=br)
C2(0,0) + C2(0,1)
Creates a branching rule.
INPUT:
If the rule parameter is omitted, in some cases, a default rule is supplied. See branch_weyl_character().
EXAMPLES:
sage: rule = branching_rule(CartanType("A3"),CartanType("C2"),"symmetric")
sage: [rule(x) for x in WeylCharacterRing("A3").fundamental_weights()]
[[1, 0], [1, 1], [1, 0]]
Create the branching rule of a plethysm.
INPUT:
It is assumed that the image of the irreducible representation pi
naturally has its image in the group .
Returns a branching rule for this plethysm.
EXAMPLES:
The adjoint representation factors
through
. The branching rule in question will
describe how representations of
composed with
this homomorphism decompose into irreducible characters
of
:
sage: A2 = WeylCharacterRing("A2")
sage: A2 = WeylCharacterRing("A2", style="coroots")
sage: ad = A2.adjoint_representation(); ad
A2(1,1)
sage: ad.degree()
8
sage: ad.frobenius_schur_indicator()
1
This confirms that has degree 8 and is orthogonal,
hence factors through
which is type
:
sage: br = branching_rule_from_plethysm(ad,"D4")
sage: D4 = WeylCharacterRing("D4")
sage: [D4(f).branch(A2,rule = br) for f in D4.fundamental_weights()]
[A2(1,1), A2(0,3) + A2(1,1) + A2(3,0), A2(1,1), A2(1,1)]
Creates a branching rule.
INPUT:
If the rule parameter is omitted, in some cases, a default rule is supplied. See branch_weyl_character().
EXAMPLES:
sage: rule = branching_rule(CartanType("A3"),CartanType("C2"),"symmetric")
sage: [rule(x) for x in WeylCharacterRing("A3").fundamental_weights()]
[[1, 0], [1, 1], [1, 0]]
Given a classical Cartan type (of rank less than or equal to 8) this prints the Cartan types of maximal subgroups, with a method of obtaining the branching rule. The string to the right of the colon in the output is a command to create a branching rule.
INPUT:
Returns a list of maximal subgroups of ct.
EXAMPLES:
sage: from sage.combinat.root_system.branching_rules import maximal_subgroups
sage: maximal_subgroups("D4")
B3:branching_rule("D4","B3","symmetric")
A2:branching_rule("D4","A2(1,1)","plethysm")
A1xC2:branching_rule("D4","C1xC2","tensor")*branching_rule("C1xC2","A1xC2",[branching_rule("C1","A1","isomorphic"),"identity"])
A1xA1xA1xA1:branching_rule("D4","D2xD2","orthogonal_sum")*branching_rule("D2xD2","A1xA1xA1xA1",[branching_rule("D2","A1xA1","isomorphic"),branching_rule("D2","A1xA1","isomorphic")])