# Weyl Character Rings¶

class sage.combinat.root_system.weyl_characters.WeightRing(parent, prefix)

The weight ring, which is the group algebra over a weight lattice.

A Weyl character may be regarded as an element of the weight ring. In fact, an element of the weight ring is an element of the weyl character ring if and only if it is invariant under the action of the Weyl group.

The advantage of the weight ring over the Weyl character ring is that one may conduct calculations in the weight ring that involve sums of weights that are not Weyl group invariant.

EXAMPLES:

sage: A2 = WeylCharacterRing(['A',2])
sage: a2 = WeightRing(A2)
sage: wd = prod(a2(x/2)-a2(-x/2) for x in a2.space().positive_roots()); wd
a2(-1,1,0) - a2(-1,0,1) - a2(1,-1,0) + a2(1,0,-1) + a2(0,-1,1) - a2(0,1,-1)
sage: chi = A2([5,3,0]); chi
A2(5,3,0)
sage: a2(chi)
a2(1,2,5) + 2*a2(1,3,4) + 2*a2(1,4,3) + a2(1,5,2) + a2(2,1,5)
+ 2*a2(2,2,4) + 3*a2(2,3,3) + 2*a2(2,4,2) + a2(2,5,1) + 2*a2(3,1,4)
+ 3*a2(3,2,3) + 3*a2(3,3,2) + 2*a2(3,4,1) + a2(3,5,0) + a2(3,0,5)
+ 2*a2(4,1,3) + 2*a2(4,2,2) + 2*a2(4,3,1) + a2(4,4,0) + a2(4,0,4)
+ a2(5,1,2) + a2(5,2,1) + a2(5,3,0) + a2(5,0,3) + a2(0,3,5)
+ a2(0,4,4) + a2(0,5,3)
sage: a2(chi)*wd
-a2(-1,3,6) + a2(-1,6,3) + a2(3,-1,6) - a2(3,6,-1) - a2(6,-1,3) + a2(6,3,-1)
sage: sum((-1)^w.length()*a2([6,3,-1]).weyl_group_action(w) for w in a2.space().weyl_group())
-a2(-1,3,6) + a2(-1,6,3) + a2(3,-1,6) - a2(3,6,-1) - a2(6,-1,3) + a2(6,3,-1)
sage: a2(chi)*wd == sum((-1)^w.length()*a2([6,3,-1]).weyl_group_action(w) for w in a2.space().weyl_group())
True

class Element(M, x)

A class for weight ring elements.

cartan_type()

Return the Cartan type.

EXAMPLES:

sage: A2=WeylCharacterRing("A2")
sage: a2 = WeightRing(A2)
sage: a2([0,1,0]).cartan_type()
['A', 2]

character()

Assuming that self is invariant under the Weyl group, this will express it as a linear combination of characters. If self is not Weyl group invariant, this method will not terminate.

EXAMPLES:

sage: A2 = WeylCharacterRing(['A',2])
sage: a2 = WeightRing(A2)
sage: W = a2.space().weyl_group()
sage: mu = a2(2,1,0)
sage: nu = sum(mu.weyl_group_action(w) for w in W) ; nu
a2(1,2,0) + a2(1,0,2) + a2(2,1,0) + a2(2,0,1) + a2(0,1,2) + a2(0,2,1)
sage: nu.character()
-2*A2(1,1,1) + A2(2,1,0)

demazure(w, debug=False)

Return the result of applying the Demazure operator $$\partial_w$$ to self.

INPUT:

• w – a Weyl group element, or its reduced word

If $$w = s_i$$ is a simple reflection, the operation $$\partial_w$$ sends the weight $$\lambda$$ to

$\frac{\lambda - s_i \cdot \lambda + \alpha_i}{1 + \alpha_i}$

where the numerator is divisible the denominator in the weight ring. This is extended by multiplicativity to all $$w$$ in the Weyl group.

EXAMPLES:

sage: B2 = WeylCharacterRing("B2",style="coroots")
sage: b2=WeightRing(B2)
sage: b2(1,0).demazure([1])
b2(1,0) + b2(-1,2)
sage: b2(1,0).demazure([2])
b2(1,0)
sage: r=b2(1,0).demazure([1,2]); r
b2(1,0) + b2(-1,2)
sage: r.demazure([1])
b2(1,0) + b2(-1,2)
sage: r.demazure([2])
b2(0,0) + b2(1,0) + b2(1,-2) + b2(-1,2)

demazure_lusztig(i, v)

Return the result of applying the Demazure-Lusztig operator $$T_i$$ to self.

INPUT:

• i – an element of the index set (or a reduced word or Weyl group element)
• v – an element of the base ring

If $$R$$ is the parent WeightRing, the Demazure-Lusztig operator $$T_i$$ is the linear map $$R \to R$$ that sends (for a weight $$\lambda$$) $$R(\lambda)$$ to

$(R(\alpha_i)-1)^{-1} \bigl(R(\lambda) - R(s_i\lambda) - v(R(\lambda) - R(\alpha_i + s_i \lambda)) \bigr)$

where the numerator is divisible by the denominator in $$R$$. The Demazure-Lusztig operators give a representation of the Iwahori–Hecke algebra associated to the Weyl group. See

• Lusztig, Equivariant $$K$$-theory and representations of Hecke algebras, Proc. Amer. Math. Soc. 94 (1985), no. 2, 337-342.
• Cherednik, Nonsymmetric Macdonald polynomials. IMRN 10, 483-515 (1995).

In the examples, we confirm the braid and quadratic relations for type $$B_2$$.

EXAMPLES:

sage: P.<v> = PolynomialRing(QQ)
sage: B2 = WeylCharacterRing("B2",style="coroots",base_ring=P); b2 = B2.ambient()
sage: def T1(f) : return f.demazure_lusztig(1,v)
sage: def T2(f) : return f.demazure_lusztig(2,v)
sage: T1(T2(T1(T2(b2(1,-1)))))
(v^2-v)*b2(0,-1) + v^2*b2(-1,1)
sage: [T1(T1(f))==(v-1)*T1(f)+v*f for f in [b2(0,0), b2(1,0), b2(2,3)]]
[True, True, True]
sage: [T1(T2(T1(T2(b2(i,j))))) == T2(T1(T2(T1(b2(i,j))))) for i in [-2..2] for j in [-1,1]]
[True, True, True, True, True, True, True, True, True, True]


Instead of an index $$i$$ one may use a reduced word or Weyl group element:

sage: b2(1,0).demazure_lusztig([2,1],v)==T2(T1(b2(1,0)))
True
sage: W = B2.space().weyl_group(prefix="s")
sage: [s1,s2]=W.simple_reflections()
sage: b2(1,0).demazure_lusztig(s2*s1,v)==T2(T1(b2(1,0)))
True

scale(k)

Multiplies a weight by $$k$$. The operation is extended by linearity to the weight ring.

INPUT:

• k – a nonzero integer

EXAMPLES:

sage: g2 = WeylCharacterRing("G2",style="coroots").ambient()
sage: g2(2,3).scale(2)
g2(4,6)

shift(mu)

Add $$\mu$$ to any weight. Extended by linearity to the weight ring.

INPUT:

• mu – a weight

EXAMPLES:

sage: g2 = WeylCharacterRing("G2",style="coroots").ambient()
sage: [g2(1,2).shift(fw) for fw in g2.fundamental_weights()]
[g2(2,2), g2(1,3)]

weyl_group_action(w)

Return the action of the Weyl group element w on self.

EXAMPLES:

sage: G2 = WeylCharacterRing(['G',2])
sage: g2 = WeightRing(G2)
sage: L = g2.space()
sage: [fw1, fw2] = L.fundamental_weights()
sage: sum(g2(fw2).weyl_group_action(w) for w in L.weyl_group())
2*g2(-2,1,1) + 2*g2(-1,-1,2) + 2*g2(-1,2,-1) + 2*g2(1,-2,1) + 2*g2(1,1,-2) + 2*g2(2,-1,-1)

WeightRing.cartan_type()

Return the Cartan type.

EXAMPLES:

sage: A2 = WeylCharacterRing("A2")
sage: WeightRing(A2).cartan_type()
['A', 2]

WeightRing.fundamental_weights()

Return the fundamental weights.

EXAMPLES:

sage: WeightRing(WeylCharacterRing("G2")).fundamental_weights()
Finite family {1: (1, 0, -1), 2: (2, -1, -1)}

WeightRing.one_basis()

Return the index of $$1$$.

EXAMPLES:

sage: A3=WeylCharacterRing("A3")
sage: WeightRing(A3).one_basis()
(0, 0, 0, 0)
sage: WeightRing(A3).one()
a3(0,0,0,0)

WeightRing.parent()

Return the parent Weyl character ring.

EXAMPLES:

sage: A2=WeylCharacterRing("A2")
sage: a2=WeightRing(A2)
sage: a2.parent()
The Weyl Character Ring of Type ['A', 2] with Integer Ring coefficients
sage: a2.parent() == A2
True

WeightRing.positive_roots()

Return the positive roots.

EXAMPLES:

sage: WeightRing(WeylCharacterRing("G2")).positive_roots()
[(0, 1, -1), (1, -2, 1), (1, -1, 0), (1, 0, -1), (1, 1, -2), (2, -1, -1)]

WeightRing.product_on_basis(a, b)

Return the product of basis elements indexed by a and b.

EXAMPLES:

sage: A2=WeylCharacterRing("A2")
sage: a2=WeightRing(A2)
sage: a2(1,0,0) * a2(0,1,0) # indirect doctest
a2(1,1,0)

WeightRing.simple_roots()

Return the simple roots.

EXAMPLES:

sage: WeightRing(WeylCharacterRing("G2")).simple_roots()
Finite family {1: (0, 1, -1), 2: (1, -2, 1)}

WeightRing.some_elements()

Return some elements of self.

EXAMPLES:

sage: A3=WeylCharacterRing("A3")
sage: a3=WeightRing(A3)
sage: a3.some_elements()
[a3(1,0,0,0), a3(1,1,0,0), a3(1,1,1,0)]

WeightRing.space()

Return the weight space realization associated to self.

EXAMPLES:

sage: E8 = WeylCharacterRing(['E',8])
sage: e8 = WeightRing(E8)
sage: e8.space()
Ambient space of the Root system of type ['E', 8]

WeightRing.weyl_character_ring()

Return the parent Weyl Character Ring. A synonym for self.parent().

EXAMPLES:

sage: A2=WeylCharacterRing("A2")
sage: a2=WeightRing(A2)
sage: a2.weyl_character_ring()
The Weyl Character Ring of Type ['A', 2] with Integer Ring coefficients

WeightRing.wt_repr(wt)

Return a string representing the irreducible character with highest weight vector wt. Uses coroot notation if the associated Weyl character ring is defined with style="coroots".

EXAMPLES:

sage: G2 = WeylCharacterRing("G2")
sage: [G2.ambient().wt_repr(x) for x in G2.fundamental_weights()]
['g2(1,0,-1)', 'g2(2,-1,-1)']
sage: G2 = WeylCharacterRing("G2",style="coroots")
sage: [G2.ambient().wt_repr(x) for x in G2.fundamental_weights()]
['g2(1,0)', 'g2(0,1)']

class sage.combinat.root_system.weyl_characters.WeylCharacterRing(ct, base_ring=Integer Ring, prefix=None, style='lattice')

A class for rings of Weyl characters.

Let $$K$$ be a compact Lie group, which we assume is semisimple and simply-connected. Its complexified Lie algebra $$L$$ is the Lie algebra of a complex analytic Lie group $$G$$. The following three categories are equivalent: finite-dimensional representations of $$K$$; finite-dimensional representations of $$L$$; and finite-dimensional analytic representations of $$G$$. In every case, there is a parametrization of the irreducible representations by their highest weight vectors. For this theory of Weyl, see (for example):

• Adams, Lectures on Lie groups
• Broecker and Tom Dieck, Representations of Compact Lie groups
• Bump, Lie Groups
• Fulton and Harris, Representation Theory
• Goodman and Wallach, Representations and Invariants of the Classical Groups
• Hall, Lie Groups, Lie Algebras and Representations
• Humphreys, Introduction to Lie Algebras and their representations
• Procesi, Lie Groups
• Samelson, Notes on Lie Algebras
• Varadarajan, Lie groups, Lie algebras, and their representations
• Zhelobenko, Compact Lie Groups and their Representations.

Computations that you can do with these include computing their weight multiplicities, products (thus decomposing the tensor product of a representation into irreducibles) and branching rules (restriction to a smaller group).

There is associated with $$K$$, $$L$$ or $$G$$ as above a lattice, the weight lattice, whose elements (called weights) are characters of a Cartan subgroup or subalgebra. There is an action of the Weyl group $$W$$ on the lattice, and elements of a fixed fundamental domain for $$W$$, the positive Weyl chamber, are called dominant. There is for each representation a unique highest dominant weight that occurs with nonzero multiplicity with respect to a certain partial order, and it is called the highest weight vector.

EXAMPLES:

sage: L = RootSystem("A2").ambient_space()
sage: [fw1,fw2] = L.fundamental_weights()
sage: R = WeylCharacterRing(['A',2], prefix="R")
sage: [R(1),R(fw1),R(fw2)]
[R(0,0,0), R(1,0,0), R(1,1,0)]


Here R(1), R(fw1), and R(fw2) are irreducible representations with highest weight vectors $$0$$, $$\Lambda_1$$, and $$\Lambda_2$$ respecitively (the first two fundamental weights).

For type $$A$$ (also $$G_2$$, $$F_4$$, $$E_6$$ and $$E_7$$) we will take as the weight lattice not the weight lattice of the semisimple group, but for a larger one. For type $$A$$, this means we are concerned with the representation theory of $$K = U(n)$$ or $$G = GL(n, \CC)$$ rather than $$SU(n)$$ or $$SU(n, \CC)$$. This is useful since the representation theory of $$GL(n)$$ is ubiquitous, and also since we may then represent the fundamental weights (in sage.combinat.root_system.root_system) by vectors with integer entries. If you are only interested in $$SL(3)$$, say, use WeylCharacterRing(['A',2]) as above but be aware that R([a,b,c]) and R([a+1,b+1,c+1]) represent the same character of $$SL(3)$$ since R([1,1,1]) is the determinant.

For more information, see the thematic tutorial Lie Methods and Related Combinatorics in Sage, available at:

http://www.sagemath.org/doc/thematic_tutorials/lie.html

class Element(M, x)

A class for Weyl characters.

Return the $$r$$-th Adams operation of self.

INPUT:

• r – a positive integer

This is a virtual character, whose weights are the weights of self, each multiplied by $$r$$.

EXAMPLES:

sage: A2=WeylCharacterRing("A2")
A2(2,2,2) - A2(3,2,1) + A2(3,3,0)

branch(S, rule='default')

Return the restriction of the character to the subalgebra. If no rule is specified, we will try to specify one.

INPUT:

• S – a Weyl character ring for a Lie subgroup or subalgebra
• rule – a branching rule

EXAMPLES:

sage: B3 = WeylCharacterRing(['B',3])
sage: A2 = WeylCharacterRing(['A',2])
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)]

cartan_type()

Return the Cartan type of self.

EXAMPLES:

sage: A2 = WeylCharacterRing("A2")
sage: A2([1,0,0]).cartan_type()
['A', 2]

degree()

The degree of self, that is, the dimension of module.

EXAMPLES:

sage: B3 = WeylCharacterRing(['B',3])
sage: [B3(x).degree() for x in B3.fundamental_weights()]
[7, 21, 8]

exterior_power(k)

Return the $$k$$-th exterior power of self.

INPUT:

• k – a nonnegative integer

The algorithm is based on the identity $$k e_k = \sum_{r=1}^k (-1)^{k-1} p_k e_{k-r}$$ relating the power-sum and elementary symmetric polynomials. Applying this to the eigenvalues of an element of the parent Lie group in the representation self, the $$e_k$$ become exterior powers and the $$p_k$$ become Adams operations, giving an efficient recursive implementation.

EXAMPLES:

sage: B3=WeylCharacterRing("B3",style="coroots")
sage: spin=B3(0,0,1)
sage: spin.exterior_power(6)
B3(1,0,0) + B3(0,1,0)

exterior_square()

Return the exterior square of the character.

EXAMPLES:

sage: A2 = WeylCharacterRing("A2",style="coroots")
sage: A2(1,0).exterior_square()
A2(0,1)

frobenius_schur_indicator()

Return:

• $$1$$ if the representation is real (orthogonal)
• $$-1$$ if the representation is quaternionic (symplectic)
• $$0$$ if the representation is complex (not self dual)

The Frobenius-Schur indicator of a character $$\chi$$ of a compact group $$G$$ is the Haar integral over the group of $$\chi(g^2)$$. Its value is 1, -1 or 0. This method computes it for irreducible characters of compact Lie groups by checking whether the symmetric and exterior square characters contain the trivial character.

Todo

Try to compute this directly without actually calculating the full symmetric and exterior squares.

EXAMPLES:

sage: B2 = WeylCharacterRing("B2",style="coroots")
sage: B2(1,0).frobenius_schur_indicator()
1
sage: B2(0,1).frobenius_schur_indicator()
-1

inner_product(other)

Compute the inner product with another character.

The irreducible characters are an orthonormal basis with respect to the usual inner product of characters, interpreted as functions on a compact Lie group, by Schur orthogonality.

INPUT:

• other – another character

EXAMPLES:

sage: A2 = WeylCharacterRing("A2")
sage: [f1,f2]=A2.fundamental_weights()
sage: r1 = A2(f1)*A2(f2); r1
A2(1,1,1) + A2(2,1,0)
sage: r2 = A2(f1)^3; r2
A2(1,1,1) + 2*A2(2,1,0) + A2(3,0,0)
sage: r1.inner_product(r2)
3

invariant_degree()

Return the multiplicity of the trivial representation in self.

Multiplicities of other irreducibles may be obtained using multiplicity().

EXAMPLES:

sage: A2 = WeylCharacterRing("A2",style="coroots")
sage: rep = A2(1,0)^2*A2(0,1)^2; rep
2*A2(0,0) + A2(0,3) + 4*A2(1,1) + A2(3,0) + A2(2,2)
sage: rep.invariant_degree()
2

is_irreducible()

Return whether self is an irreducible character.

EXAMPLES:

sage: B3 = WeylCharacterRing(['B',3])
sage: [B3(x).is_irreducible() for x in B3.fundamental_weights()]
[True, True, True]
sage: sum(B3(x) for x in B3.fundamental_weights()).is_irreducible()
False

multiplicity(other)

Return the multiplicity of the irreducible other in self.

INPUT:

• other – an irreducible character

EXAMPLES:

sage: B2 = WeylCharacterRing("B2",style="coroots")
sage: rep = B2(1,1)^2; rep
B2(0,0) + B2(1,0) + 2*B2(0,2) + B2(2,0) + 2*B2(1,2) + B2(0,4) + B2(3,0) + B2(2,2)
sage: rep.multiplicity(B2(0,2))
2

symmetric_power(k)

Return the $$k$$-th symmetric power of self.

INPUT:

• $$k$$ – a nonnegative integer

The algorithm is based on the identity $$k h_k = \sum_{r=1}^k p_k h_{k-r}$$ relating the power-sum and complete symmetric polynomials. Applying this to the eigenvalues of an element of the parent Lie group in the representation self, the $$h_k$$ become symmetric powers and the $$p_k$$ become Adams operations, giving an efficient recursive implementation.

EXAMPLES:

sage: B3=WeylCharacterRing("B3",style="coroots")
sage: spin=B3(0,0,1)
sage: spin.symmetric_power(6)
B3(0,0,0) + B3(0,0,2) + B3(0,0,4) + B3(0,0,6)

symmetric_square()

Return the symmetric square of the character.

EXAMPLES:

sage: A2 = WeylCharacterRing("A2",style="coroots")
sage: A2(1,0).symmetric_square()
A2(2,0)

weight_multiplicities()

Produce the dictionary of weight multiplicities for the Weyl character self. The character does not have to be irreducible.

EXAMPLES:

sage: B2=WeylCharacterRing("B2",style="coroots")
sage: B2(0,1).weight_multiplicities()
{(-1/2, 1/2): 1, (-1/2, -1/2): 1, (1/2, -1/2): 1, (1/2, 1/2): 1}

WeylCharacterRing.ambient()

Returns the weight ring of self.

EXAMPLES:

sage: WeylCharacterRing("A2").ambient()
The Weight ring attached to The Weyl Character Ring of Type ['A', 2] with Integer Ring coefficients

WeylCharacterRing.base_ring()

Return the base ring of self.

EXAMPLES:

sage: R = WeylCharacterRing(['A',3], base_ring = CC); R.base_ring()
Complex Field with 53 bits of precision

WeylCharacterRing.cartan_type()

Return the Cartan type of self.

EXAMPLES:

sage: WeylCharacterRing("A2").cartan_type()
['A', 2]

WeylCharacterRing.char_from_weights(mdict)

Construct a Weyl character from an invariant linear combination of weights.

INPUT:

• mdict – a dictionary mapping weights to coefficients, and representing a linear combination of weights which shall be invariant under the action of the Weyl group

OUTPUT: the corresponding Weyl character

EXAMPLES:

sage: A2 = WeylCharacterRing("A2")
sage: v = A2._space([3,1,0]); v
(3, 1, 0)
sage: d = dict([(x,1) for x in v.orbit()]); d
{(3, 0, 1): 1, (1, 0, 3): 1, (0, 1, 3): 1, (1, 3, 0): 1, (3, 1, 0): 1, (0, 3, 1): 1}
sage: A2.char_from_weights(d)
-A2(2,1,1) - A2(2,2,0) + A2(3,1,0)

WeylCharacterRing.demazure_character(hwv, word, debug=False)

Compute the Demazure character.

INPUT:

• hwv – a (usually dominant) weight
• word – a Weyl group word

Produces the Demazure character with highest weight hwv and word as an element of the weight ring. Only available if style="coroots". The Demazure operators are also available as methods of WeightRing elements, and as methods of crystals. Given a CrystalOfTableaux with given highest weight vector, the Demazure method on the crystal will give the equivalent of this method, except that the Demazure character of the crystal is given as a sum of monomials instead of an element of the WeightRing.

EXAMPLES:

sage: A2=WeylCharacterRing("A2",style="coroots")
sage: h=sum(A2.fundamental_weights()); h
(2, 1, 0)
sage: A2.demazure_character(h,word=[1,2])
a2(0,0) + a2(-2,1) + a2(2,-1) + a2(1,1) + a2(-1,2)
sage: A2.demazure_character((1,1),word=[1,2])
a2(0,0) + a2(-2,1) + a2(2,-1) + a2(1,1) + a2(-1,2)

WeylCharacterRing.dot_reduce(a)

Auxiliary function for product_on_basis().

Return a pair $$[\epsilon, b]$$ where $$b$$ is a dominant weight and $$\epsilon$$ is 0, 1 or -1. To describe $$b$$, let $$w$$ be an element of the Weyl group such that $$w(a + \rho)$$ is dominant. If $$w(a + \rho) - \rho$$ is dominant, then $$\epsilon$$ is the sign of $$w$$ and $$b$$ is $$w(a + \rho) - \rho$$. Otherwise, $$\epsilon$$ is zero.

INPUT:

• a – a weight

EXAMPLES:

sage: A2=WeylCharacterRing("A2")
sage: weights=A2(2,1,0).weight_multiplicities().keys(); weights
[(1, 2, 0), (2, 1, 0), (0, 2, 1), (2, 0, 1), (0, 1, 2), (1, 1, 1), (1, 0, 2)]
sage: [A2.dot_reduce(x) for x in weights]
[[0, (0, 0, 0)], [1, (2, 1, 0)], [-1, (1, 1, 1)], [0, (0, 0, 0)], [0, (0, 0, 0)], [1, (1, 1, 1)], [-1, (1, 1, 1)]]

WeylCharacterRing.dynkin_diagram()

Return the Dynkin diagram of self.

EXAMPLES:

sage: WeylCharacterRing("E7").dynkin_diagram()
O 2
|
|
O---O---O---O---O---O
1   3   4   5   6   7
E7

WeylCharacterRing.extended_dynkin_diagram()

Return the extended Dynkin diagram, which is the Dynkin diagram of the corresponding untwisted affine type.

EXAMPLES:

sage: WeylCharacterRing("E7").extended_dynkin_diagram()
O 2
|
|
O---O---O---O---O---O---O
0   1   3   4   5   6   7
E7~

WeylCharacterRing.fundamental_weights()

Return the fundamental weights.

EXAMPLES:

sage: WeylCharacterRing("G2").fundamental_weights()
Finite family {1: (1, 0, -1), 2: (2, -1, -1)}

WeylCharacterRing.highest_root()

Return the highest_root.

EXAMPLES:

sage: WeylCharacterRing("G2").highest_root()
(2, -1, -1)

WeylCharacterRing.irr_repr(hwv)

Return a string representing the irreducible character with highest weight vector hwv.

EXAMPLES:

sage: B3 = WeylCharacterRing("B3")
sage: [B3.irr_repr(v) for v in B3.fundamental_weights()]
['B3(1,0,0)', 'B3(1,1,0)', 'B3(1/2,1/2,1/2)']
sage: B3 = WeylCharacterRing("B3", style="coroots")
sage: [B3.irr_repr(v) for v in B3.fundamental_weights()]
['B3(1,0,0)', 'B3(0,1,0)', 'B3(0,0,1)']

WeylCharacterRing.lift()

The embedding of self into its weight ring.

EXAMPLES:

sage: A2 = WeylCharacterRing("A2")
sage: A2.lift
Generic morphism:
From: The Weyl Character Ring of Type ['A', 2] with Integer Ring coefficients
To:   The Weight ring attached to The Weyl Character Ring of Type ['A', 2] with Integer Ring coefficients

sage: x = -A2(2,1,1) - A2(2,2,0) + A2(3,1,0)
sage: A2.lift(x)
a2(1,3,0) + a2(1,0,3) + a2(3,1,0) + a2(3,0,1) + a2(0,1,3) + a2(0,3,1)


As a shortcut, you may also do:

sage: x.lift()
a2(1,3,0) + a2(1,0,3) + a2(3,1,0) + a2(3,0,1) + a2(0,1,3) + a2(0,3,1)


Or even:

sage: a2 = WeightRing(A2)
sage: a2(x)
a2(1,3,0) + a2(1,0,3) + a2(3,1,0) + a2(3,0,1) + a2(0,1,3) + a2(0,3,1)

WeylCharacterRing.lift_on_basis(irr)

Expand the basis element indexed by the weight irr into the weight ring of self.

INPUT:

• irr – a dominant weight

This is used to implement lift().

EXAMPLES:

sage: A2 = WeylCharacterRing("A2")
sage: v = A2._space([2,1,0]); v
(2, 1, 0)
sage: A2.lift_on_basis(v)
2*a2(1,1,1) + a2(1,2,0) + a2(1,0,2) + a2(2,1,0) + a2(2,0,1) + a2(0,1,2) + a2(0,2,1)


This is consistent with the analoguous calculation with symmetric Schur functions:

sage: s = SymmetricFunctions(QQ).s()
sage: s[2,1].expand(3)
x0^2*x1 + x0*x1^2 + x0^2*x2 + 2*x0*x1*x2 + x1^2*x2 + x0*x2^2 + x1*x2^2

WeylCharacterRing.one_basis()

Return the index of 1 in self.

EXAMPLES:

sage: WeylCharacterRing("A3").one_basis()
(0, 0, 0, 0)
sage: WeylCharacterRing("A3").one()
A3(0,0,0,0)

WeylCharacterRing.positive_roots()

Return the positive roots.

EXAMPLES:

sage: WeylCharacterRing("G2").positive_roots()
[(0, 1, -1), (1, -2, 1), (1, -1, 0), (1, 0, -1), (1, 1, -2), (2, -1, -1)]

WeylCharacterRing.product_on_basis(a, b)

Compute the tensor product of two irreducible representations a and b.

EXAMPLES:

sage: D4 = WeylCharacterRing(['D',4])
sage: spin_plus = D4(1/2,1/2,1/2,1/2)
sage: spin_minus = D4(1/2,1/2,1/2,-1/2)
sage: spin_plus * spin_minus # indirect doctest
D4(1,0,0,0) + D4(1,1,1,0)
sage: spin_minus * spin_plus
D4(1,0,0,0) + D4(1,1,1,0)


Uses the Brauer-Klimyk method.

WeylCharacterRing.rank()

Return the rank.

EXAMPLES:

sage: WeylCharacterRing("G2").rank()
2

WeylCharacterRing.retract()

The partial inverse map from the weight ring into self.

EXAMPLES:

sage: A2 = WeylCharacterRing("A2")
sage: a2 = WeightRing(A2)
sage: A2.retract
Generic morphism:
From: The Weight ring attached to The Weyl Character Ring of Type ['A', 2] with Integer Ring coefficients
To:   The Weyl Character Ring of Type ['A', 2] with Integer Ring coefficients

sage: v = A2._space([3,1,0]); v
(3, 1, 0)
sage: chi = a2.sum_of_monomials(v.orbit()); chi
a2(1,3,0) + a2(1,0,3) + a2(3,1,0) + a2(3,0,1) + a2(0,1,3) + a2(0,3,1)
sage: A2.retract(chi)
-A2(2,1,1) - A2(2,2,0) + A2(3,1,0)


The input should be invariant:

sage: A2.retract(a2.monomial(v))
Traceback (most recent call last):
...
ValueError: multiplicity dictionary may not be Weyl group invariant


As a shortcut, you may use conversion:

sage: A2(chi)
-A2(2,1,1) - A2(2,2,0) + A2(3,1,0)
sage: A2(a2.monomial(v))
Traceback (most recent call last):
...
ValueError: multiplicity dictionary may not be Weyl group invariant

WeylCharacterRing.simple_coroots()

Return the simple coroots.

EXAMPLES:

sage: WeylCharacterRing("G2").simple_coroots()
Finite family {1: (0, 1, -1), 2: (1/3, -2/3, 1/3)}

WeylCharacterRing.simple_roots()

Return the simple roots.

EXAMPLES:

sage: WeylCharacterRing("G2").simple_roots()
Finite family {1: (0, 1, -1), 2: (1, -2, 1)}

WeylCharacterRing.some_elements()

Return some elements of self.

EXAMPLES:

sage: WeylCharacterRing("A3").some_elements()
[A3(1,0,0,0), A3(1,1,0,0), A3(1,1,1,0)]

WeylCharacterRing.space()

Return the weight space associated to self.

EXAMPLES:

sage: WeylCharacterRing(['E',8]).space()
Ambient space of the Root system of type ['E', 8]

sage.combinat.root_system.weyl_characters.branch_weyl_character(chi, R, S, rule='default')

A branching rule describes the restriction of representations from a Lie group or algebra $$G$$ to a smaller one $$H$$. 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.

INPUT:

• chi – a character of $$G$$
• R – the Weyl Character Ring of $$G$$
• S – the Weyl Character Ring of $$H$$
• rule – a set of $$r$$ dominant weights in $$H$$ where $$r$$ is the rank of $$G$$ or one of the following:
• "levi"
• "automorphic"
• "symmetric"
• "extended"
• "orthogonal_sum"
• "tensor"
• "triality"
• "miscellaneous"

The use of the various input to rule will be explained next. After the examples we will explain how to write your own branching rules for cases that we have omitted.

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.

You may try omitting the rule if it is “obvious”. Default rules are provided for the following cases:

\begin{split}\begin{aligned} A_{2s} & \to B_s, \\ A_{2s-1} & \to C_s, \\ A_{2*s-1} & \to D_s. \end{aligned}\end{split}

The above default rules correspond to embedding the group $$SO(2s+1)$$, $$Sp(2s)$$ or $$SO(2s)$$ into the corresponding general or special linear group by the standard representation. Default rules are also specified for the following cases:

\begin{split}\begin{aligned} B_{s+1} & \to D_s, \\ D_s & \to B_s. \end{aligned}\end{split}

These correspond to the embedding of $$O(n)$$ into $$O(n+1)$$ where $$n = 2s$$ or $$2s + 1$$. 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. Currently we require that the smaller diagram be connected. For these rules use the option rule="levi":

\begin{split}\begin{aligned} A_r & \to A_{r-1} \\ B_r & \to A_{r-1} \\ B_r & \to B_{r-1} \\ C_r & \to A_{r-1} \\ C_r & \to C_{r-1} \\ D_r & \to A_{r-1} \\ D_r & \to D_{r-1} \\ E_r & \to A_{r-1} \quad r = 7,8 \\ E_r & \to D_{r-1} \quad r = 6,7,8 \\ E_r & \to E_{r-1} \\ F_4 & \to B_3 \\ F_4 & \to C_3 \\ G_2 & \to A_1 \text{(short root)} \end{aligned}\end{split}

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 $$G_2 \to A_1$$ corresponding to the long root is available by first branching $$G_2 \to A_2$$ then $$A_2 \to A_1$$. Similarly the branching rules to the Levi subgroup:

$E_r \to A_{r-1} \quad r = 6,7,8$

may be obtained by first branching $$E_6 \to A_5 \times A_1$$, $$E_7 \to A_7$$ or $$E_8 \to A_8$$.

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: D5 = WeylCharacterRing("D5")
sage: G2 = WeylCharacterRing("G2")
sage: F4 = WeylCharacterRing("F4",style="coroots")
sage: E6=WeylCharacterRing("E6",style="coroots")
sage: D5=WeylCharacterRing("D5",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 $$B_3$$ being branched is spin, which is not a representation of $$SO(7)$$ but of its double cover $$\mathrm{spin}(7)$$. The group $$A_2$$ is really GL(3) and the double cover of $$SO(7)$$ induces a cover of $$GL(3)$$ that is trivial over $$SL(3)$$ but not over the center of $$GL(3)$$. The weight lattice for this $$GL(3)$$ consists of triples $$(a,b,c)$$ of half integers such that $$a - b$$ and $$b - c$$ are in $$\ZZ$$, 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]] # long time (3s)
[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: D6=WeylCharacterRing("D6",style="coroots")
sage: fw = E7.fundamental_weights()
sage: [E7(fw[i]).branch(D6,rule="levi") for i in [1,2,7]] # long time (26s)
[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") # not tested (very long time) (121s)
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 (3s)
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 (36s)
[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 (6s)
[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 $$D_4$$ having order 3. Use rule="automorphic" (or for $$D_4$$ rule="triality"):

\begin{split}\begin{aligned} A_r & \to A_r \\ D_r & \to D_r \\ E_6 & \to E_6 \end{aligned}\end{split}

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 $$D_4$$ 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 $$G$$ admits an outer automorphism (usually of degree 2) we may consider the branching rule to the isotropy subgroup $$H$$. In many cases the Dynkin diagram of $$H$$ can be obtained by folding the Dynkin diagram of $$G$$. For such isotropy subgroups use rule="symmetric". The last branching rule, $$D_4 \to G_2$$ is not to a maximal subgroup since $$D_4 \to B_3 \to G_2$$, but it is included for convenience.

$\begin{split}A_{2r+1} & \to B_r \\ A_{2r} & \to C_r \\ A_{2r} & \to D_r \\ D_r & \to B_{r-1} \\ E_6 & \to F_4 \\ D_4 & \to G_2\end{split}$

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 (36s)
[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)]


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 $$B$$, such as $$D_6 \to B_3 \times B_3$$.

Here is the extended Dynkin diagram for $$D_6$$:

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

Removing the node 3 results in an embedding $$D_3 \times D_3 \to D_6$$. This corresponds to the embedding $$SO(6) \times SO(6) \to SO(12)$$, and is of extended type. On the other hand the embedding $$SO(5) \times SO(7) \to SO(12)$$ (e.g. $$B_2 \times B_3 \to D_6$$) cannot be explained this way but for uniformity is implemented under rule="extended".

The following rules are implemented as special cases of rule="extended":

\begin{split}\begin{aligned} E_6 & \to A_5 \times A_1, A_2 \times A_2 \times A_2 \\ E_7 & \to A_7, D_6 \times A_1, A_3 \times A_3 \times A_1 \\ E_8 & \to A_8, D_8, E_7 \times A_1, A_4 \times A_4, D_5 \times A_3, E_6 \times A_2 \\ F_4 & \to B_4, C_3 \times A_1, A_2 \times A_2, A_3 \times A_1 \\ G_2 => A_1 \times A_1 \end{aligned}\end{split}

Note that $$E_8$$ 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 (9s)
[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") # long time (5s)
A7(0,0,0,1,0,0,0) + A7(1,0,0,0,0,0,1)
sage: E8=WeylCharacterRing("E8",style="coroots")
sage: D8=WeylCharacterRing("D8",style="coroots")
sage: E8(0,0,0,0,0,0,0,1).branch(D8,rule="extended") # long time (19s)
D8(0,0,0,0,0,0,1,0) + D8(0,1,0,0,0,0,0,0)
sage: F4(1,0,0,0).branch(A1xC3,rule="extended") # (0.7s)
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 $$n = a + b + c + \cdots$$, you can get any branching rule

\begin{split}\begin{aligned} SO(n) & \to SO(a) \times SO(b) \times SO(c) \times \cdots, \\ Sp(2n) & \to Sp(2a) \times Sp(2b) \times Sp(2c) x \times \cdots, \end{aligned}\end{split}

where $$O(a)$$ is type $$D_r$$ for $$a = 2r$$ or $$B_r$$ for $$a = 2r+1$$ and $$Sp(2r)$$ is type $$C_r$$. In some cases these are also of extended type, as in the case $$D_3 \times D_3 \to D_6$$ discussed above. But in other cases, for example $$B_3 \times B_3 \to D_7$$, they are not of extended type.

Tensor

There are branching rules:

\begin{split}\begin{aligned} A_{rs-1} & \to A_{r-1} \times A_{s-1}, \\ B_{2rs+r+s} & \to B_r \times B_s, \\ D_{2rs+s} & \to B_r \times D_s, \\ D_{2rs} & \to D_r \times D_s, \\ D_{2rs} & \to C_r \times C_s, \\ C_{2rs+s} & \to B_r \times C_s, \\ C_{2rs} & \to C_r \times D_s. \end{aligned}\end{split}

corresponding to the tensor product homomorphism. For type $$A$$, the homomorphism is $$GL(r) \times GL(s) \to GL(rs)$$. For the classical types, the relevant fact is that if $$V, W$$ are orthogonal or symplectic spaces, that is, spaces endowed with symmetric or skew-symmetric bilinear forms, then $$V \otimes W$$ is also an orthogonal space (if $$V$$ and $$W$$ are both orthogonal or both symplectic) or symplectic (if one of $$V$$ and $$W$$ 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 $$k$$-th symmetric and exterior power homomorphisms map

$GL(n) \to GL\left(\binom{n+k-1}{k}\right) \times 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:

\begin{split}\begin{aligned} B_r & \to A_1 \\ C_r & \to A_1 \end{aligned}\end{split}

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 rules:

\begin{split}\begin{aligned} B_3 & \to G_2, \\ F_4 & \to G_2 \times A_1 \text{(not implemented yet)}. \end{aligned}\end{split}

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)


Branching Rules From Plethysms

Nearly all branching rules $$G \to H$$ where $$G$$ is of type $$A$$, $$B$$, $$C$$ or $$D$$ are covered by the preceding rules. The function branching_rule_from_plethysm() covers the remaining cases.

EXAMPLES:

This is a general rule that includes any branching rule from types $$A$$, $$B$$, $$C$$, or $$D$$ 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 $$G$$ to a maximal subgroup $$H$$ such that $$\mathrm{rank}(H) < \mathrm{rank}(G) - 1$$.

We consider a homomorphism $$H \to G$$ where $$G$$ is one of $$SL(r+1)$$, $$SO(2r+1)$$, $$Sp(2r)$$ or $$SO(2r)$$. The function branching_rule_from_plethysm() produces the corresponding branching rule. The main ingredient is the character $$\chi$$ of the representation of $$H$$ that is the homomorphism to $$GL(r+1)$$, $$GL(2r+1)$$ or $$GL(2r)$$.

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 $$SL(2)$$.

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 $$SL(2) \to Sp(6)$$, and there is a corresponding branching rule $$C_3 \to A_1$$.

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")
14
1
sage: spin = D7(0,0,0,0,0,1,0); spin.degree()
64
G2(1,1)


We have confirmed that the adjoint representation of $$G_2$$ gives a homomorphism into $$SO(14)$$, and that the pullback of the one of the two 64 dimensional spin representations to $$SO(14)$$ is an irreducible representation of $$G_2$$.

Isomorphic Type

Although not usually referred to as a branching rule, the effects of the accidental isomorphisms may be handled using rule="isomorphic":

\begin{split}\begin{aligned} B_2 & \to C_2 \\ C_2 & \to B_2 \\ A_3 & \to D_3 \\ D_3 & \to A_3 \\ D_2 & \to A_1 \to A_1 \\ B_1 & \to A_1 \\ C_1 & \to A_1 \end{aligned}\end{split}

EXAMPLES:

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: [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 $$A_3(x,y,z,w)$$ can be understood as a representation of $$SL(4)$$. The weights $$x,y,z,w$$ and $$x+t,y+t,z+t,w+t$$ represent the same representation of $$SL(4)$$ - though not of $$GL(4)$$ - since $$A_3(x+t,y+t,z+t,w+t)$$ is the same as $$A_3(x,y,z,w)$$ tensored with $$\mathrm{det}^t$$. So as a representation of $$SL(4)$$, A3(1/4,1/4,1/4,-3/4) is the same as A3(1,1,1,0). The exterior square representation $$SL(4) \to GL(6)$$ admits an invariant symmetric bilinear form, so is a representation $$SL(4) \to SO(6)$$ that lifts to an isomorphism $$SL(4) \to \mathrm{Spin}(6)$$. Conversely, there are two isomorphisms $$SO(6) \to SL(4)$$, 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 Root System

If you are branching from a reducible root system, the rule is a list of rules, one for each component type in the root system. The rules in the list are given in pairs [type, rule], where type is the root system to be branched to, and rule is the branching rule.

EXAMPLES:

sage: D4 = WeylCharacterRing("D4",style="coroots")
sage: D2xD2 = WeylCharacterRing("D2xD2",style="coroots")
sage: A1xA1xA1xA1 = WeylCharacterRing("A1xA1xA1xA1",style="coroots")
sage: rr = [["A1xA1","isomorphic"],["A1xA1","isomorphic"]]
sage: [D4(fw) for fw in D4.fundamental_weights()]
[D4(1,0,0,0), D4(0,1,0,0), D4(0,0,1,0), D4(0,0,0,1)]
sage: [D4(fw).branch(D2xD2,rule="extended").branch(A1xA1xA1xA1,rule=rr) 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)]


Suppose you want to branch from a group $$G$$ to a subgroup $$H$$. Arrange the embedding so that a Cartan subalgebra $$U$$ of $$H$$ is contained in a Cartan subalgebra $$T$$ of $$G$$. There is thus a mapping from the weight spaces $$\mathrm{Lie}(T)^* \to \mathrm{Lie}(U)^*$$. Two embeddings will produce identical branching rules if they differ by an element of the Weyl group of $$H$$.

The rule is this map $$\mathrm{Lie}(T)^*$$, which is G.space(), to $$\mathrm{Lie}(U)^*$$, which is H.space(), which you may implement as a function. As an example, let us consider how to implement the branching rule $$A_3 \to C_2$$. Here $$H = C_2 = Sp(4)$$ embedded as a subgroup in $$A_3 = GL(4)$$. The Cartan subalgebra $$U$$ consists of diagonal matrices with eigenvalues $$u_1, u_2, -u_2, -u_1$$. The C2.space() is the two dimensional vector spaces consisting of the linear functionals $$u_1$$ and $$u_2$$ on $$U$$. On the other hand $$\mathrm{Lie}(T)$$ is $$\RR^4$$. A convenient way to see the restriction is to think of it as the adjoint of the map $$(u_1, u_2) \to (u_1,u_2, -u_2, -u_1)$$, that is, $$(x_0, x_1, x_2, x_3) \to (x_0 - x_3, x_1 - x_2)$$. 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]]


EXAMPLES:

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

sage.combinat.root_system.weyl_characters.branching_rule_from_plethysm(chi, cartan_type, return_matrix=False)

Create the branching rule of a plethysm.

INPUT:

• chi – the character of an irreducible representation $$\pi$$ of a group $$G$$
• cartan_type – a classical Cartan type ($$A$$,B,C or $$D$$).

It is assumed that the image of the irreducible representation pi naturally has its image in the group $$G$$.

Returns a branching rule for this plethysm.

EXAMPLES:

The adjoint representation $$SL(3) \to GL(8)$$ factors through $$SO(8)$$. The branching rule in question will describe how representations of $$SO(8)$$ composed with this homomorphism decompose into irreducible characters of $$SL(3)$$:

sage: A2 = WeylCharacterRing("A2")
sage: A2 = WeylCharacterRing("A2", style="coroots")
8
1


This confirms that $$ad$$ has degree 8 and is orthogonal, hence factors through $$SO(8)$$ which is type $$D_4$$:

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

sage.combinat.root_system.weyl_characters.get_branching_rule(Rtype, Stype, rule)

Creates a branching rule.

INPUT:

• R – the Weyl Character Ring of $$G$$
• S – the Weyl Character Ring of $$H$$
• rule – a string describing the branching rule as a map from the weight space of $$S$$ to the weight space of $$R$$.

If the rule parameter is omitted, in a very few cases, a default rule is supplied. See branch_weyl_character().

EXAMPLES:

sage: rule = get_branching_rule(CartanType("A3"),CartanType("C2"),"symmetric")
sage: [rule(x) for x in WeylCharacterRing("A3").fundamental_weights()]
[[1, 0], [1, 1], [1, 0]]

sage.combinat.root_system.weyl_characters.irreducible_character_freudenthal(hwv, debug=False)

Return the dictionary of multiplicities for the irreducible character with highest weight $$\lambda$$.

The weight multiplicities are computed by the Freudenthal multiplicity formula. The algorithm is based on recursion relation that is stated, for example, in Humphrey’s book on Lie Algebras. The multiplicities are invariant under the Weyl group, so to compute them it would be sufficient to compute them for the weights in the positive Weyl chamber. However after some testing it was found to be faster to compute every weight using the recursion, since the use of the Weyl group is expensive in its current implementation.

INPUT:

• hwv – a dominant weight in a weight lattice.
• L – the ambient space

EXAMPLES:

sage: WeylCharacterRing("A2")(2,1,0).weight_multiplicities() # indirect doctest
{(1, 2, 0): 1, (2, 1, 0): 1, (0, 2, 1): 1, (2, 0, 1): 1, (0, 1, 2): 1, (1, 1, 1): 2, (1, 0, 2): 1}
`

Weyl Groups

#### Next topic

Root system data for affine Cartan types