Coerces the element into the ring.
INPUT:
EXAMPLES:
sage: a2 = WeightRing(WeylCharacterRing(['A',2]))
sage: a2(-1)
-a2(0,0,0)
EXAMPLES:
sage: E8 = WeylCharacterRing(['E',8])
sage: e8 = WeightRing(E8)
sage: A3 = WeylCharacterRing(['A', 3])
sage: a3 = WeightRing(A3)
sage: e8 == e8
True
sage: e8 == a3
False
Creates an auxiliary ring for the weights of a representation. This ring is associated with a WeylCharacterRing. The weights of a representation of a Lie group G or algebra are the characters of the characters of a Cartan subgroup T or subalgebra that occur when the representation is restricted to that Cartan. If a linear combination of weights is invariant under the Weyl group, then it is a linear combination of characters of G.
As with the WeylCharacterRing, you may want to make sure that the prefix matches the name that you assign the ring, so that the __call__ method can parse the ring’s own output. If you do not assign a prefix, one is automatically generated by changing the case of the prefix to the associated WeylCharacterRing, from upper case to lower case. However you may assign your own prefixes to both rings.
INPUT:
EXAMPLES:
sage: A2 = WeylCharacterRing(['A',2])
sage: a2 = WeightRing(A2)
sage: wd = prod(a2(x/2)-a2(-x/2) for x in a2.lattice().positive_roots()); wd
-a2(-1,0,1) + a2(-1,1,0) + a2(0,-1,1) - a2(0,1,-1) - a2(1,-1,0) + a2(1,0,-1)
sage: chi = A2([5,3,0]); chi
A2(5,3,0)
sage: a2(chi)
a2(0,3,5) + a2(0,4,4) + a2(0,5,3) + 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) + a2(3,0,5) + 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(4,0,4) + 2*a2(4,1,3) + 2*a2(4,2,2) +
2*a2(4,3,1) + a2(4,4,0) + a2(5,0,3) + a2(5,1,2) + a2(5,2,1) + a2(5,3,0)
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.lattice().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.lattice().weyl_group())
True
In the above example, we create a WeylCharacterRing A2 whose objects are the characters. Attached to this is a second WeightRing called a2. The Weyl denominator is created and labeled wd. This is the product of factors a2(alpha/2)-a2(-alpha/2) where alpha runs through the positive roots. Then character chi with highest weight [5,3,0] is created and coerced into a2. It has many terms. It is multiplied by wd and compared with the alternating sum of its images under Weyl group elements. These are equal, illustrating the Weyl character formula.
EXAMPLES:
sage: R = WeylCharacterRing(['G',2], prefix = "R", base_ring = QQ)
sage: S = WeightRing(R, prefix = "S")
sage: L = S.lattice()
sage: vc = [sum(S(1/2)*S(f).weyl_group_action(w) for w in L.weyl_group()) for f in L.fundamental_weights()]; vc
[S(-1,0,1) + S(-1,1,0) + S(0,-1,1) + S(0,1,-1) + S(1,-1,0) + S(1,0,-1),
S(-2,1,1) + S(-1,-1,2) + S(-1,2,-1) + S(1,-2,1) + S(1,1,-2) + S(2,-1,-1)]
sage: [v.character() for v in vc]
[-R(0,0,0) + R(1,0,-1), -R(0,0,0) - R(1,0,-1) + R(2,-1,-1)]
TESTS:
sage: R = WeylCharacterRing(['G',2], prefix = "R", base_ring = QQ)
sage: S = WeightRing(R, prefix = "S")
sage: S == loads(dumps(S))
True
EXAMPLES:
sage: P.<q>=QQ[]
sage: G2 = WeylCharacterRing(['G',2], base_ring = P)
sage: WeightRing(G2)
The Weight ring attached to The Weyl Character Ring of Type [G,2] with Univariate Polynomial Ring in q over Rational Field coefficients
Coercion from the base ring.
EXAMPLES:
sage: G2 = WeylCharacterRing(['G',2])
sage: g2 = WeightRing(G2)
sage: 2 in g2
True
Returns the base ring.
EXAMPLES:
sage: R = WeylCharacterRing(['A',3], base_ring = CC); R.base_ring()
Complex Field with 53 bits of precision
Returns the Cartan Type.
EXAMPLES:
sage: A2 = WeylCharacterRing("A2")
sage: WeightRing(A2).cartan_type()
['A', 2]
Returns the weight lattice realization associated to self.
EXAMPLES:
sage: E8 = WeylCharacterRing(['E',8])
sage: e8 = WeightRing(E8)
sage: e8.lattice()
Ambient space of the Root system of type ['E', 8]
Returns a string representing the irreducible character with highest weight vectr wt.
EXAMPLES:
sage: G2 = WeylCharacterRing(['G',2])
sage: g2 = WeightRing(G2)
sage: g2.wt_repr([1,0,0])
'g2(1,0,0)'
A class for weights, and linear combinations of weights. See WeightRing? for more information.
EXAMPLES:
sage: B3 = WeylCharacterRing(['B',3])
sage: b3 = WeightRing(B3)
sage: fw = [b3(w) for w in b3.lattice().fundamental_weights()]
sage: sorted(fw)
[b3(1/2,1/2,1/2), b3(1,0,0), b3(1,1,0)]
INPUT:
EXAMPLES:
sage: A2 = WeylCharacterRing(['A',2])
sage: a2 = WeightRing(A2)
sage: a2 == loads(dumps(a2))
True
EXAMPLES:
sage: A2 = WeylCharacterRing(['A',2])
sage: a2 = WeightRing(A2)
sage: chi = A2([2,1,0])
sage: chi^4
8*A2(4,4,4) + 32*A2(5,4,3) + 20*A2(5,5,2) + 20*A2(6,3,3) + 33*A2(6,4,2) + 15*A2(6,5,1) + 2*A2(6,6,0) + 15*A2(7,3,2) + 12*A2(7,4,1) + 3*A2(7,5,0) + 2*A2(8,2,2) + 3*A2(8,3,1) + A2(8,4,0)
sage: a2(chi)^4
a2(0,4,8) + 4*a2(0,5,7) + 6*a2(0,6,6) + 4*a2(0,7,5) + a2(0,8,4) + 4*a2(1,3,8) + 20*a2(1,4,7) + 40*a2(1,5,6) + 40*a2(1,6,5) + 20*a2(1,7,4) + 4*a2(1,8,3) + 6*a2(2,2,8) + 40*a2(2,3,7) + 106*a2(2,4,6) + 144*a2(2,5,5) + 106*a2(2,6,4) + 40*a2(2,7,3) + 6*a2(2,8,2) + 4*a2(3,1,8) + 40*a2(3,2,7) + 144*a2(3,3,6) + 260*a2(3,4,5) + 260*a2(3,5,4) + 144*a2(3,6,3) + 40*a2(3,7,2) + 4*a2(3,8,1) + a2(4,0,8) + 20*a2(4,1,7) + 106*a2(4,2,6) + 260*a2(4,3,5) + 346*a2(4,4,4) + 260*a2(4,5,3) + 106*a2(4,6,2) + 20*a2(4,7,1) + a2(4,8,0) + 4*a2(5,0,7) + 40*a2(5,1,6) + 144*a2(5,2,5) + 260*a2(5,3,4) + 260*a2(5,4,3) + 144*a2(5,5,2) + 40*a2(5,6,1) + 4*a2(5,7,0) + 6*a2(6,0,6) + 40*a2(6,1,5) + 106*a2(6,2,4) + 144*a2(6,3,3) + 106*a2(6,4,2) + 40*a2(6,5,1) + 6*a2(6,6,0) + 4*a2(7,0,5) + 20*a2(7,1,4) + 40*a2(7,2,3) + 40*a2(7,3,2) + 20*a2(7,4,1) + 4*a2(7,5,0) + a2(8,0,4) + 4*a2(8,1,3) + 6*a2(8,2,2) + 4*a2(8,3,1) + a2(8,4,0)
sage: (a2(chi)^4).character() == chi^4
True
EXAMPLES:
sage: B3 = WeylCharacterRing(['B',3])
sage: b3 = WeightRing(B3)
sage: fw = b3.lattice().fundamental_weights()
sage: b3(fw[3])
b3(1/2,1/2,1/2)
sage: b3(B3(fw[3]))
b3(-1/2,-1/2,-1/2) + b3(-1/2,-1/2,1/2) + b3(-1/2,1/2,-1/2) + b3(-1/2,1/2,1/2) + b3(1/2,-1/2,-1/2) + b3(1/2,-1/2,1/2) + b3(1/2,1/2,-1/2) + b3(1/2,1/2,1/2)
EXAMPLES:
sage: A2 = WeylCharacterRing(['A',2])
sage: a2 = WeightRing(A2)
sage: [a2(0,0,0)+a2(2,1,0), a2(2,1,0)+a2(0,0,0), - a2(0,0,0)+2*a2(0,0,0), -2*a2(0,0,0)+a2(0,0,0), -a2(2,1,0)+2*a2(2,1,0)-a2(2,1,0)]
[a2(0,0,0) + a2(2,1,0), a2(0,0,0) + a2(2,1,0), a2(0,0,0), -a2(0,0,0), 0]
EXAMPLES:
sage: A2 = WeylCharacterRing(['A',2])
sage: a2 = WeightRing(A2)
sage: [chi, mu] = [A2(1,0,0), A2(1,1,0)]
sage: chi*mu
A2(1,1,1) + A2(2,1,0)
sage: a2(chi)*a2(mu)
a2(0,1,2) + a2(0,2,1) + a2(1,0,2) + 3*a2(1,1,1) + a2(1,2,0) + a2(2,0,1) + a2(2,1,0)
sage: (a2(chi)*a2(mu)).character() == chi*mu
True
EXAMPLES:
sage: A2 = WeylCharacterRing(['A',2])
sage: a2 = WeightRing(A2)
sage: [-x for x in [a2(0,0,0), 2*a2(0,0,0), -a2(0,0,0), -2*a2(0,0,0)]]
[-a2(0,0,0), -2*a2(0,0,0), a2(0,0,0), 2*a2(0,0,0)]
EXAMPLES:
sage: A2 = WeylCharacterRing(['A',2])
sage: a2 = WeightRing(A2)
sage: chi = a2(0,0,0)+2*a2(1,0,0)+3*a2(2,0,0)
sage: mu = 3*a2(0,0,0)+2*a2(1,0,0)+a2(2,0,0)
sage: chi - mu
-2*a2(0,0,0) + 2*a2(2,0,0)
Returns the representation of a single weight.
EXAMPLES:
sage: A2 = WeylCharacterRing(['A',2])
sage: a2 = WeightRing(A2)
sage: a2([1,0,0])
a2(1,0,0)
Returns 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.lattice().weyl_group()
sage: mu = a2(2,1,0)
sage: nu = sum(mu.weyl_group_action(w) for w in W)
sage: nu
a2(0,1,2) + a2(0,2,1) + a2(1,0,2) + a2(1,2,0) + a2(2,0,1) + a2(2,1,0)
sage: nu.character()
-2*A2(1,1,1) + A2(2,1,0)
Returns a list of weights in self with their multiplicities.
EXAMPLES:
sage: G2 = WeylCharacterRing(['G',2])
sage: g2 = WeightRing(G2)
sage: pr = sum(g2(a) for a in g2.lattice().positive_roots())
sage: sorted(pr.mlist())
[[(1, -2, 1), 1], [(1, -1, 0), 1], [(1, 1, -2), 1], [(1, 0, -1), 1], [(2, -1, -1), 1], [(0, 1, -1), 1]]
Returns the actionof the Weyl group element w on self.
EXAMPLES:
sage: G2 = WeylCharacterRing(['G',2])
sage: g2 = WeightRing(G2)
sage: L = g2.lattice()
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)
A class for 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: representations of K; representations of L; and 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) J. F. Adams, Lectures on Lie groups; Broecker and Tom Dieck, Representations of Compact Lie groups; Bump, Lie Groups, Part I; Fulton and Harris, Representation Theory, Part IV; Goodman and Wallach, Representations and Invariants of the Classical Groups, Chapter 5; 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; or Zhelobenko, Compact Lie Groups and their Representations.
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(['A',2]).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, and the first two fundamental weights.
A Weyl character is a character (not necessarily irreducible) of a reductive Lie group or algebra. It is represented by a pair of dictionaries. The mdict is a dictionary of weight multiplicities. The hdict is a dictionary of highest weight vectors of the irreducible characters that occur in its decomposition into irreducibles, with the multiplicities in this decomposition.
For type A (also ,
,
and
) 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 root_system.py) 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.
EXAMPLES:
sage: B3 = WeylCharacterRing(['B',3])
sage: fw = [B3(w) for w in B3.lattice().fundamental_weights()]
sage: sorted(fw)
[B3(1/2,1/2,1/2), B3(1,0,0), B3(1,1,0)]
sage: b = B3(1,0,0)
sage: b == b
True
INPUT:
EXAMPLES:
sage: R = WeylCharacterRing(['B',3], prefix = "R")
sage: r = R(1,1,0)
sage: r == loads(dumps(r))
True
Returns .
The coefficients in are the degrees of those
irreducible representations of the symmetric group
corresponding to partitions of length
.
EXAMPLES:
sage: A2 = WeylCharacterRing(['A',2])
sage: chi = A2(1,0,0)
sage: [chi^k for k in range(6)]
[A2(0,0,0),
A2(1,0,0),
A2(1,1,0) + A2(2,0,0),
A2(1,1,1) + 2*A2(2,1,0) + A2(3,0,0),
3*A2(2,1,1) + 2*A2(2,2,0) + 3*A2(3,1,0) + A2(4,0,0),
5*A2(2,2,1) + 6*A2(3,1,1) + 5*A2(3,2,0) + 4*A2(4,1,0) + A2(5,0,0)]
EXAMPLES:
sage: R = WeylCharacterRing(['B',3], prefix = "R")
sage: [R(w) for w in R.lattice().fundamental_weights()]
[R(1,0,0), R(1,1,0), R(1/2,1/2,1/2)]
EXAMPLES:
sage: A2 = WeylCharacterRing(['A',2])
sage: [A2(0,0,0)+A2(2,1,0), A2(2,1,0)+A2(0,0,0), - A2(0,0,0)+2*A2(0,0,0), -2*A2(0,0,0)+A2(0,0,0), -A2(2,1,0)+2*A2(2,1,0)-A2(2,1,0)]
[A2(0,0,0) + A2(2,1,0), A2(0,0,0) + A2(2,1,0), A2(0,0,0), -A2(0,0,0), 0]
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
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)
EXAMPLES:
sage: A2 = WeylCharacterRing(['A',2])
sage: [-x for x in [A2(0,0,0), 2*A2(0,0,0), -A2(0,0,0), -2*A2(0,0,0)]]
[-A2(0,0,0), -2*A2(0,0,0), A2(0,0,0), 2*A2(0,0,0)]
EXAMPLES:
sage: A2 = WeylCharacterRing(['A',2])
sage: chi = A2(0,0,0)+2*A2(1,0,0)+3*A2(2,0,0)
sage: mu = 3*A2(0,0,0)+2*A2(1,0,0)+A2(2,0,0)
sage: chi - mu
-2*A2(0,0,0) + 2*A2(2,0,0)
Returns 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.lattice().fundamental_weights()]
[A2(0,0,-1) + A2(0,0,0) + A2(1,0,0),
A2(0,-1,-1) + A2(0,0,-1) + A2(0,0,0) + A2(1,0,-1) + A2(1,0,0) + A2(1,1,0),
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)]
Returns the Cartan Type.
EXAMPLES:
sage: A2=WeylCharacterRing("A2")
sage: A2([1,0,0]).cartan_type()
['A', 2]
To check the correctness of an element, we compare the theoretical dimension computed Weyl character formula with the actual one obtained by adding up the multiplicities.
EXAMPLES:
sage: F4 = WeylCharacterRing(['F',4])
sage: [F4(x).check(verbose = true) for x in F4.lattice().fundamental_weights()]
[[52, 52], [1274, 1274], [273, 273], [26, 26]]
The degree of the character, that is, the dimension of module.
EXAMPLES:
sage: B3 = WeylCharacterRing(['B',3])
sage: [B3(x).degree() for x in B3.lattice().fundamental_weights()]
[7, 21, 8]
Returns a list of highest weight vectors and multiplicities of the irreducible characters in self.
EXAMPLES:
sage: B3 = WeylCharacterRing(['B',3])
sage: B3(1/2,1/2,1/2).hlist()
[[(1/2, 1/2, 1/2), 1]]
Returns a list of weights in self with their multiplicities.
EXAMPLES:
sage: B3 = WeylCharacterRing(['B',3])
sage: sorted(B3(1/2,1/2,1/2).mlist())
[[(-1/2, -1/2, -1/2), 1], [(-1/2, -1/2, 1/2), 1], [(-1/2, 1/2, -1/2), 1], [(-1/2, 1/2, 1/2), 1], [(1/2, -1/2, -1/2), 1], [(1/2, -1/2, 1/2), 1], [(1/2, 1/2, -1/2), 1], [(1/2, 1/2, 1/2), 1]]
EXAMPLES:
sage: B3 = WeylCharacterRing(['B',3])
sage: B3(2).parent()
The Weyl Character Ring of Type [B,3] with Integer Ring coefficients
A class for rings of Weyl characters. The Weyl character is a character of a semisimple (or reductive) Lie group or algebra. They form a ring, in which the addition and multiplication correspond to direct sum and tensor product of representations.
INPUT:
OPTIONAL ARGUMENTS:
If no prefix specified, one is generated based on the Cartan type. It is good to name the ring after the prefix, since then it can parse its own output.
EXAMPLES:
sage: G2 = WeylCharacterRing(['G',2])
sage: [fw1,fw2] = G2.lattice().fundamental_weights()
sage: 2*G2(2*fw1+fw2)
2*G2(4,-1,-3)
sage: 2*G2(4,-1,-3)
2*G2(4,-1,-3)
sage: G2(4,-1,-3).degree()
189
Note that since the ring was named after its default prefix, it
was able to parse its own output. You do not have to use the
default prefix. Thus:
EXAMPLES:
sage: R = WeylCharacterRing(['B',3], prefix='R')
sage: chi = R(R.lattice().fundamental_weights()[3]); chi
R(1/2,1/2,1/2)
sage: R(1/2,1/2,1/2) == chi
True
The multiplication in R corresponds to the product of characters, which you can use to determine the decomposition of tensor products into irreducibles. For example, let us compute the tensor product of the standard and spin representations of Spin(7).
EXAMPLES:
sage: B3 = WeylCharacterRing(['B',3])
sage: [fw1,fw2,fw3]=B3.lattice().fundamental_weights()
sage: [B3(fw1).degree(),B3(fw3).degree()]
[7, 8]
sage: B3(fw1)*B3(fw3)
B3(1/2,1/2,1/2) + B3(3/2,1/2,1/2)
The name of the irreducible representation encodes the highest weight vector.
TESTS:
sage: F4 = WeylCharacterRing(['F',4], cache = True)
sage: [fw1,fw2,fw3,fw4] = F4.lattice().fundamental_weights()
sage: chi = F4(fw4); chi, chi.degree()
(F4(1,0,0,0), 26)
sage: chi^2
F4(0,0,0,0) + F4(1,0,0,0) + F4(1,1,0,0) + F4(3/2,1/2,1/2,1/2) + F4(2,0,0,0)
sage: [x.degree() for x in [F4(0,0,0,0), F4(1,0,0,0), F4(1,1,0,0), F4(3/2,1/2,1/2,1/2), F4(2,0,0,0)]]
[1, 26, 52, 273, 324]
You can produce a list of the irreducible elements of an irreducible character.
EXAMPLES:
sage: R = WeylCharacterRing(['A',2], prefix = R)
sage: sorted(R([2,1,0]).mlist())
[[(1, 1, 1), 2], [(1, 2, 0), 1], [(1, 0, 2), 1], [(2, 1, 0), 1], [(2, 0, 1), 1], [(0, 1, 2), 1], [(0, 2, 1), 1]]
Coerces the element into the ring. You may pass a vector in the ambient lattice, an element of the base_ring, or an argument list of integers (or half-integers for the spin types) which are the components of a vector in the ambient lattice.
INPUT:
EXAMPLES:
sage: A2 = WeylCharacterRing(['A',2])
sage: [A2(x) for x in [-2,-1,0,1,2]]
[-2*A2(0,0,0), -A2(0,0,0), 0, A2(0,0,0), 2*A2(0,0,0)]
sage: [A2(2,1,0), A2([2,1,0]), A2(2,1,0)== A2([2,1,0])]
[A2(2,1,0), A2(2,1,0), True]
sage: A2([2,1,0]) == A2(2,1,0)
True
sage: l = -2*A2(0,0,0) - A2(1,0,0) + A2(2,0,0) + 2*A2(3,0,0)
sage: [l in A2, A2(l) == l]
[True, True]
sage: P.<q> = QQ[]
sage: A2 = WeylCharacterRing(['A',2], base_ring = P)
sage: [A2(x) for x in [-2,-1,0,1,2,-2*q,-q,q,2*q,(1-q)]]
[-2*A2(0,0,0), -A2(0,0,0), 0, A2(0,0,0), 2*A2(0,0,0), -2*q*A2(0,0,0), -q*A2(0,0,0),
q*A2(0,0,0), 2*q*A2(0,0,0), (-q+1)*A2(0,0,0)]
EXAMPLES:
sage: A3 = WeylCharacterRing(['A',3])
sage: B3 = WeylCharacterRing(['B',3])
sage: A3 == A3
True
sage: A3 == B3
False
EXAMPLES:
sage: R = WeylCharacterRing(['A',3])
sage: R == loads(dumps(R))
True
EXAMPLES:
sage: WeylCharacterRing(['A',3])
The Weyl Character Ring of Type [A,3] with Integer Ring coefficients
Coercion from the base ring.
EXAMPLES:
sage: R = WeylCharacterRing(['G',2])
sage: 2 in R
True
sage: R._coerce_impl(2)
2*G2(0,0,0)
Returns the base ring.
EXAMPLES:
sage: R = WeylCharacterRing(['A',3], base_ring = CC); R.base_ring()
Complex Field with 53 bits of precision
Returns the Cartan Type.
EXAMPLES:
sage: WeylCharacterRing("A2").cartan_type()
['A', 2]
Return the hdict given just a dictionary of weight multiplicities.
This will not terminate unless the dictionary of weight multiplicities is Weyl group invariant.
EXAMPLES:
sage: B3 = WeylCharacterRing(['B',3])
sage: m = B3(1,0,0)._mdict
sage: B3.char_from_weights(m)
{(1, 0, 0): 1}
Return a string representing the irreducible character with highest weight vectr hwv.
EXAMPLES:
sage: A2 = WeylCharacterRing(['A',2])
sage: A2.irr_repr([2,1,0])
'A2(2,1,0)'
Returns the weight lattice associated to self.
EXAMPLES:
sage: WeylCharacterRing(['E',8]).lattice()
Ambient space of the Root system of type ['E', 8]
A Branching rule describes the restriction of representations from a Lie group or algebra G 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 or Howe, Tan and Willenbring, Stable branching rules for classical symmetric pairs, Trans. Amer. Math. Soc. 357 (2005), no. 4, 1601-1626.
INPUT:
You may use a predefined rule by specifying rule = one of”levi”, “automorphic”, “symmetric”, “extended”, “triality” or “miscellaneous”. The use of these rules will be explained next. After the examples we will explain how to write your own branching rules for cases that we have omitted. (Rules for the exceptional groups have not yet been coded.)
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 these for the cases where the Dynkin diagram of S is connected. This excludes branching rules such as A3 -> A1 x A1, which are not yet implemented.
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”:
['A',r] -> ['A',r-1]
['B',r] -> ['A',r-1]
['B',r] -> ['B',r-1]
['C',r] -> ['A',r-1]
['C',r] -> ['C',r-1]
['D',r] -> ['A',r-1]
['D',r] -> ['D',r-1]
['E',r] -> ['A',r-1] r = 6,7,8 (not implemented yet)
['E',r] -> ['D',r-1] r = 6,7,8 (not implemented yet)
['E',r] -> ['E',r-1] r = 6,7 (not implemented yet)
['F',4] -> ['B',3] (not implemented yet)
['F',4] -> ['C',3] (not implemented yet)
['G',2] -> ['A',1] (short root) (not implemented yet)
The other Levi branching rule from ->
corresponding to the
long root is available by first branching
->
then branching to
A1.
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 D4 having order 3. Use rule=”automorphic” or rule=”triality”
[‘A’,r] - [‘A’,r] [‘D’,r] - [‘D’,r] [‘E’,6] - [‘E’,6] (not implemented yet)
SYMMETRIC TYPE. Related to the automorphic type, when the Dynkin diagram has a symmetry there is a branching rule to the subalgebra (or subgroup) of invariants under the automorphism. Use rule=”symmetric”.
[‘A’,2r+1] - [‘B’,r] [‘A’,2r] - [‘C’,r] [‘D’,r] - [‘B’,r-1] [‘E’,6] - [‘F’,4] (not implemented yet) [‘D’,4] - [‘G’,2] (not implemented yet)
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.
[‘G’,2] - [‘A’,2] (not implemented yet) [‘B’,r] - [‘D’,r] [‘F’,4] - [‘B’,4] (not implemented yet) [‘E’,7] - [‘A’,7] (not implemented yet) [‘E’,8] - [‘A’,8] (not implemented yet)
MISCELLANEOUS: Use rule=”miscellaneous” for the following rule, which does not fit into the above framework.
[‘B’,3] - [‘G’,2] (Not implemented yet.)
ISOMORPHIC TYPE: Although not usually referred to as a branching rule, the effects of the accidental isomorphisms may be handled using rule=”isomorphic”
[‘B’,2] - [‘C’,2] [‘C’,2] - [‘B’,2] [‘A’,3] - [‘D’,3] [‘D’,3] - [‘A’,3]
EXAMPLES: (Levi type)
sage: A2 = WeylCharacterRing(['A',2])
sage: B2 = WeylCharacterRing(['B',2])
sage: C2 = WeylCharacterRing(['C',2])
sage: A3 = WeylCharacterRing(['A',3])
sage: B3 = WeylCharacterRing(['B',3])
sage: C3 = WeylCharacterRing(['C',3])
sage: D3 = WeylCharacterRing(['D',3])
sage: A4 = WeylCharacterRing(['A',4])
sage: D4 = WeylCharacterRing(['D',4])
sage: A5 = WeylCharacterRing(['A',5])
sage: D5 = WeylCharacterRing(['D',5])
sage: [B3(w).branch(A2,rule="levi") for w in B3.lattice().fundamental_weights()]
[A2(0,0,-1) + A2(0,0,0) + A2(1,0,0),
A2(0,-1,-1) + A2(0,0,-1) + A2(0,0,0) + A2(1,0,-1) + A2(1,0,0) + A2(1,1,0),
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 B3 being branched is spin, which is not a representation of
SO(7) but of its double cover spin(7). The group A2 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 , and this is reflected in the last
decomposition.
sage: [C3(w).branch(A2,rule="levi") for w in C3.lattice().fundamental_weights()]
[A2(0,0,-1) + A2(1,0,0),
A2(0,-1,-1) + A2(1,0,-1) + A2(1,1,0),
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.lattice().fundamental_weights()]
[A3(0,0,0,-1) + A3(1,0,0,0),
A3(0,0,-1,-1) + A3(0,0,0,0) + A3(1,0,0,-1) + A3(1,1,0,0),
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.lattice().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.lattice().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.lattice().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)]
EXAMPLES: (Automorphic type, including D4 triality)
sage: [A3(chi).branch(A3,rule="automorphic") for chi in A3.lattice().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.lattice().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)]
sage: [D4(chi).branch(D4,rule="triality") for chi in D4.lattice().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)]
EXAMPLES: (Symmetric type)
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.lattice().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.lattice().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.lattice().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)]
EXAMPLES: (Extended type)
sage: [B3(x).branch(D3,rule="extended") for x in B3.lattice().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)]
EXAMPLES: (Isomorphic type)
sage: [B2(x).branch(C2, rule="isomorphic") for x in B2.lattice().fundamental_weights()]
[C2(1,1), C2(1,0)]
sage: [C2(x).branch(B2, rule="isomorphic") for x in C2.lattice().fundamental_weights()]
[B2(1/2,1/2), B2(1,0)]
sage: [A3(x).branch(D3,rule="isomorphic") for x in A3.lattice().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.lattice().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 A3(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
A3(x+t,y+t,z+t,w+t) is the same as A3(x,y,z,w) tensored with
. 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) -> GL(6) admits an invariant symmetric
bilinear form, so is a representation SL(4) -> SO(6) that lifts to
an isomorphism SL(4) -> Spin(6). Conversely, there are two
isomorphisms SO(6) -> SL(4), of which we’ve selected one.
You may also write your own rules. We may arrange a Cartan subalgebra U of H to be contained in a Cartan subalgebra T of G. This embedding must be chosen in a particular way - the restriction of the positive Weyl chamber in G.lattice() must be contained in the positive Weyl chamber in H.lattice(). The RULE is the adjoint of this embedding U - T, which is a mapping from the dual space of T, which is the weight space of G, to the weight space of H.
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
Returns the dictionary of multiplicities for the irreducible character with highest weight lamb. 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: