Bases: sage.combinat.free_module.CombinatorialFreeModule
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
Bases: sage.combinat.free_module.CombinatorialFreeModuleElement
A class for weight ring elements.
Return the Cartan type.
EXAMPLES:
sage: A2=WeylCharacterRing("A2")
sage: a2 = WeightRing(A2)
sage: a2([0,1,0]).cartan_type()
['A', 2]
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)
Return the result of applying the Demazure operator
to self.
INPUT:
If is a simple reflection, the operation
sends the weight
to
where the numerator is divisible the denominator in the weight
ring. This is extended by multiplicativity to all 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)
Return the result of applying the Demazure-Lusztig operator
to self.
INPUT:
If is the parent WeightRing, the Demazure-Lusztig operator
is the linear map
that sends (for a weight
)
to
where the numerator is divisible by the denominator in .
The Demazure-Lusztig operators give a representation of the
Iwahori–Hecke algebra associated to the Weyl group. See
In the examples, we confirm the braid and quadratic relations
for type .
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 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
Multiplies a weight by . The operation is extended by linearity
to the weight ring.
INPUT:
EXAMPLES:
sage: g2 = WeylCharacterRing("G2",style="coroots").ambient()
sage: g2(2,3).scale(2)
g2(4,6)
Add to any weight. Extended by linearity to the weight ring.
INPUT:
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)]
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)
Return the Cartan type.
EXAMPLES:
sage: A2 = WeylCharacterRing("A2")
sage: WeightRing(A2).cartan_type()
['A', 2]
Return the fundamental weights.
EXAMPLES:
sage: WeightRing(WeylCharacterRing("G2")).fundamental_weights()
Finite family {1: (1, 0, -1), 2: (2, -1, -1)}
Return the index of .
EXAMPLES:
sage: A3=WeylCharacterRing("A3")
sage: WeightRing(A3).one_basis()
(0, 0, 0, 0)
sage: WeightRing(A3).one()
a3(0,0,0,0)
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
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)]
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)
Return the simple roots.
EXAMPLES:
sage: WeightRing(WeylCharacterRing("G2")).simple_roots()
Finite family {1: (0, 1, -1), 2: (1, -2, 1)}
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)]
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]
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
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)']
Bases: sage.combinat.free_module.CombinatorialFreeModule
A class for rings of Weyl characters.
Let be a compact Lie group, which we assume is semisimple and
simply-connected. Its complexified Lie algebra
is the Lie algebra of a
complex analytic Lie group
. The following three categories are
equivalent: finite-dimensional representations of
; finite-dimensional
representations of
; and finite-dimensional analytic representations of
. In every case, there is a parametrization of the irreducible
representations by their highest weight vectors. For this theory of Weyl,
see (for example):
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 ,
or
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
on
the lattice, and elements of a fixed fundamental domain for
, 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 ,
, and
respecitively
(the first two fundamental weights).
For type (also
,
,
and
) we will take as the
weight lattice not the weight lattice of the semisimple group, but for a
larger one. For type
, this means we are concerned with the
representation theory of
or
rather than
or
. This is useful since the representation theory of
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
, 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
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
Bases: sage.combinat.free_module.CombinatorialFreeModuleElement
A class for Weyl characters.
Return the -th Adams operation of self.
INPUT:
This is a virtual character,
whose weights are the weights of self, each multiplied by .
EXAMPLES:
sage: A2=WeylCharacterRing("A2")
sage: A2(1,1,0).adams_operation(3)
A2(2,2,2) - A2(3,2,1) + A2(3,3,0)
Return the restriction of the character to the subalgebra. If no rule is specified, we will try to specify one.
INPUT:
See branch_weyl_character() for more information about branching rules.
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)]
Return the Cartan type of self.
EXAMPLES:
sage: A2 = WeylCharacterRing("A2")
sage: A2([1,0,0]).cartan_type()
['A', 2]
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]
Return the -th exterior power of self.
INPUT:
The algorithm is based on the
identity 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
become exterior powers and
the
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)
Return the exterior square of the character.
EXAMPLES:
sage: A2 = WeylCharacterRing("A2",style="coroots")
sage: A2(1,0).exterior_square()
A2(0,1)
Return:
The Frobenius-Schur indicator of a character
of a compact group
is the Haar integral over the
group of
. 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
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:
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
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
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
Return the multiplicity of the irreducible other in self.
INPUT:
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
Return the -th symmetric power of self.
INPUT:
The algorithm is based on the
identity 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
become symmetric powers and
the
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)
Return the symmetric square of the character.
EXAMPLES:
sage: A2 = WeylCharacterRing("A2",style="coroots")
sage: A2(1,0).symmetric_square()
A2(2,0)
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}
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
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
Return the Cartan type of self.
EXAMPLES:
sage: WeylCharacterRing("A2").cartan_type()
['A', 2]
Construct a Weyl character from an invariant linear combination of weights.
INPUT:
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)
Compute the Demazure character.
INPUT:
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.
See WeightRing.Element.demazure() and sage.categories.classical_crystals.ClassicalCrystals.ParentMethods.demazure_character()
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)
Auxiliary function for product_on_basis().
Return a pair where
is a dominant weight and
is 0, 1 or -1. To describe
, let
be an element of
the Weyl group such that
is dominant. If
is dominant, then
is the sign of
and
is
. Otherwise,
is zero.
INPUT:
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)]]
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
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~
Return the fundamental weights.
EXAMPLES:
sage: WeylCharacterRing("G2").fundamental_weights()
Finite family {1: (1, 0, -1), 2: (2, -1, -1)}
Return the highest_root.
EXAMPLES:
sage: WeylCharacterRing("G2").highest_root()
(2, -1, -1)
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)']
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)
Expand the basis element indexed by the weight irr into the weight ring of self.
INPUT:
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
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)
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)]
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.
Return the rank.
EXAMPLES:
sage: WeylCharacterRing("G2").rank()
2
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
Return the simple coroots.
EXAMPLES:
sage: WeylCharacterRing("G2").simple_coroots()
Finite family {1: (0, 1, -1), 2: (1/3, -2/3, 1/3)}
Return the simple roots.
EXAMPLES:
sage: WeylCharacterRing("G2").simple_roots()
Finite family {1: (0, 1, -1), 2: (1, -2, 1)}
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)]
Return the weight space associated to self.
EXAMPLES:
sage: WeylCharacterRing(['E',8]).space()
Ambient space of the Root system of type ['E', 8]
A branching rule describes the restriction of representations from
a Lie group or algebra to a smaller one
. 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:
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:
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. Currently we require that the smaller diagram be connected. 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: 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 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]] # 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 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
. In many cases
the Dynkin diagram of
can be obtained by folding the Dynkin
diagram of
. For such isotropy subgroups use rule="symmetric".
The last branching rule,
is not to a maximal subgroup
since
, but it is included for convenience.
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 ,
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 (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 ,
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 rules:
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 where
is of type
,
,
or
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 ,
,
, 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
.
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(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 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 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)]
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]]
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
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(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 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]]
Return the dictionary of multiplicities for the irreducible
character with highest weight .
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:
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}