Weyl character rings - Combinatorics

Skip to content
Back to top
View this page
Edit this page

# Weyl character rings

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

  Bases: `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

      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

  Python

      >>> from sage.all import *
      >>> A2 = WeylCharacterRing(['A',Integer(2)])
      >>> a2 = WeightRing(A2)
      >>> wd = prod(a2(x/Integer(2))-a2(-x/Integer(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)
      >>> chi = A2([Integer(5),Integer(3),Integer(0)]); chi
      A2(5,3,0)
      >>> 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)
      >>> 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)
      >>> sum((-Integer(1))**w.length()*a2([Integer(6),Integer(3),-Integer(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)
      >>> a2(chi)*wd == sum((-Integer(1))**w.length()*a2([Integer(6),Integer(3),-Integer(1)]).weyl_group_action(w) for w in a2.space().weyl_group())
      True

  class Element

    Bases: `IndexedFreeModuleElement`

    A class for weight ring elements.

    cartan_type()

      Return the Cartan type.

      EXAMPLES:

      Sage

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

      Python

          >>> from sage.all import *
          >>> A2 = WeylCharacterRing("A2")
          >>> a2 = WeightRing(A2)
          >>> a2([Integer(0),Integer(1),Integer(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

          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)

      Python

          >>> from sage.all import *
          >>> A2 = WeylCharacterRing(['A',Integer(2)])
          >>> a2 = WeightRing(A2)
          >>> W = a2.space().weyl_group()
          >>> mu = a2(Integer(2),Integer(1),Integer(0))
          >>> 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)
          >>> 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

          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)

      Python

          >>> from sage.all import *
          >>> B2 = WeylCharacterRing("B2",style='coroots')
          >>> b2 = WeightRing(B2)
          >>> b2(Integer(1),Integer(0)).demazure([Integer(1)])
          b2(1,0) + b2(-1,2)
          >>> b2(Integer(1),Integer(0)).demazure([Integer(2)])
          b2(1,0)
          >>> r = b2(Integer(1),Integer(0)).demazure([Integer(1),Integer(2)]); r
          b2(1,0) + b2(-1,2)
          >>> r.demazure([Integer(1)])
          b2(1,0) + b2(-1,2)
          >>> r.demazure([Integer(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

          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]

      Python

          >>> from sage.all import *
          >>> P = PolynomialRing(QQ, names=('v',)); (v,) = P._first_ngens(1)
          >>> B2 = WeylCharacterRing("B2",style='coroots',base_ring=P); b2 = B2.ambient()
          >>> def T1(f): return f.demazure_lusztig(Integer(1), v)
          >>> def T2(f): return f.demazure_lusztig(Integer(2), v)
          >>> T1(T2(T1(T2(b2(Integer(1),-Integer(1))))))
          (v^2-v)*b2(0,-1) + v^2*b2(-1,1)
          >>> [T1(T1(f))==(v-Integer(1))*T1(f)+v*f for f in [b2(Integer(0),Integer(0)), b2(Integer(1),Integer(0)), b2(Integer(2),Integer(3))]]
          [True, True, True]
          >>> [T1(T2(T1(T2(b2(i,j))))) == T2(T1(T2(T1(b2(i,j))))) for i in (ellipsis_range(-Integer(2),Ellipsis,Integer(2))) for j in [-Integer(1),Integer(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

          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

      [Python]

          >>> from sage.all import *
          >>> b2(Integer(1),Integer(0)).demazure_lusztig([Integer(2),Integer(1)],v)==T2(T1(b2(Integer(1),Integer(0))))
          True
          >>> W = B2.space().weyl_group(prefix='s')
          >>> [s1,s2]=W.simple_reflections()
          >>> b2(Integer(1),Integer(0)).demazure_lusztig(s2*s1,v)==T2(T1(b2(Integer(1),Integer(0))))
          True

    scale(k)

      Multiply a weight by \(k\).

      The operation is extended by linearity to the weight ring.

      INPUT:

      - `k` – nonzero integer

      EXAMPLES:

      Sage

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

      Python

          >>> from sage.all import *
          >>> g2 = WeylCharacterRing("G2",style='coroots').ambient()
          >>> g2(Integer(2),Integer(3)).scale(Integer(2))
          g2(4,6)

    shift(mu)

      Add \(\mu\) to any weight.

      Extended by linearity to the weight ring.

      INPUT:

      - `mu` – a weight

      EXAMPLES:

      Sage

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

      Python

          >>> from sage.all import *
          >>> g2 = WeylCharacterRing("G2",style='coroots').ambient()
          >>> [g2(Integer(1),Integer(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

          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)

      Python

          >>> from sage.all import *
          >>> G2 = WeylCharacterRing(['G',Integer(2)])
          >>> g2 = WeightRing(G2)
          >>> L = g2.space()
          >>> [fw1, fw2] = L.fundamental_weights()
          >>> 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)

  cartan_type()

    Return the Cartan type.

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> A2 = WeylCharacterRing("A2")
        >>> WeightRing(A2).cartan_type()
        ['A', 2]

  fundamental_weights()

    Return the fundamental weights.

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> WeightRing(WeylCharacterRing("G2")).fundamental_weights()
        Finite family {1: (1, 0, -1), 2: (2, -1, -1)}

  one_basis()

    Return the index of \(1\).

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> A3 = WeylCharacterRing("A3")
        >>> WeightRing(A3).one_basis()
        (0, 0, 0, 0)
        >>> WeightRing(A3).one()
        a3(0,0,0,0)

  parent()

    Return the parent Weyl character ring.

    EXAMPLES:

    Sage

        sage: A2 = WeylCharacterRing("A2")
        sage: a2 = WeightRing(A2)
        sage: a2.parent()
        The Weyl Character Ring of Type A2 with Integer Ring coefficients
        sage: a2.parent() == A2
        True

    Python

        >>> from sage.all import *
        >>> A2 = WeylCharacterRing("A2")
        >>> a2 = WeightRing(A2)
        >>> a2.parent()
        The Weyl Character Ring of Type A2 with Integer Ring coefficients
        >>> a2.parent() == A2
        True

  positive_roots()

    Return the positive roots.

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> WeightRing(WeylCharacterRing("G2")).positive_roots()
        [(0, 1, -1), (1, -2, 1), (1, -1, 0), (1, 0, -1), (1, 1, -2), (2, -1, -1)]

  product_on_basis(a, b)

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

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> A2 = WeylCharacterRing("A2")
        >>> a2 = WeightRing(A2)
        >>> a2(Integer(1),Integer(0),Integer(0)) * a2(Integer(0),Integer(1),Integer(0)) # indirect doctest
        a2(1,1,0)

  simple_roots()

    Return the simple roots.

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> WeightRing(WeylCharacterRing("G2")).simple_roots()
        Finite family {1: (0, 1, -1), 2: (1, -2, 1)}

  some_elements()

    Return some elements of `self`.

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> A3 = WeylCharacterRing("A3")
        >>> a3 = WeightRing(A3)
        >>> a3.some_elements()
        [a3(1,0,0,0), a3(1,1,0,0), a3(1,1,1,0)]

  space()

    Return the weight space realization associated to `self`.

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> E8 = WeylCharacterRing(['E',Integer(8)])
        >>> e8 = WeightRing(E8)
        >>> e8.space()
        Ambient space of the Root system of type ['E', 8]

  weyl_character_ring()

    Return the parent Weyl Character Ring.

    A synonym for `self.parent()`.

    EXAMPLES:

    Sage

        sage: A2 = WeylCharacterRing("A2")
        sage: a2 = WeightRing(A2)
        sage: a2.weyl_character_ring()
        The Weyl Character Ring of Type A2 with Integer Ring coefficients

    Python

        >>> from sage.all import *
        >>> A2 = WeylCharacterRing("A2")
        >>> a2 = WeightRing(A2)
        >>> a2.weyl_character_ring()
        The Weyl Character Ring of Type A2 with Integer Ring coefficients

  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

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

    Python

        >>> from sage.all import *
        >>> G2 = WeylCharacterRing("G2")
        >>> [G2.ambient().wt_repr(x) for x in G2.fundamental_weights()]
        ['g2(1,0,-1)', 'g2(2,-1,-1)']
        >>> G2 = WeylCharacterRing("G2",style='coroots')
        >>> [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', k=None, conjugate=False, cyclotomic_order=None, fusion_labels=None, inject_variables=False)

  Bases: `CombinatorialFreeModule`

  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

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

  Python

      >>> from sage.all import *
      >>> L = RootSystem("A2").ambient_space()
      >>> [fw1,fw2] = L.fundamental_weights()
      >>> R = WeylCharacterRing(['A',Integer(2)], prefix='R')
      >>> [R(Integer(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\) respectively (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:

  https://doc.sagemath.org/html/en/thematic_tutorials/lie.html

  class Element

    Bases: `IndexedFreeModuleElement`

    A class for Weyl characters.

    adams_operation(r)

      alias of `adams_operator()`.

    adams_operator(r)

      Return the \(r\)-th Adams operation of `self`.

      INPUT:

      - `r` – positive integer

      This is a virtual character, whose weights are the weights of `self`, each multiplied by \(r\).

      EXAMPLES:

      Sage

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

      Python

          >>> from sage.all import *
          >>> A2 = WeylCharacterRing("A2")
          >>> A2(Integer(1),Integer(1),Integer(0)).adams_operator(Integer(3))
          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

      See `branch_weyl_character()` for more information about branching rules.

      EXAMPLES:

      Sage

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

      Python

          >>> from sage.all import *
          >>> B3 = WeylCharacterRing(['B',Integer(3)])
          >>> A2 = WeylCharacterRing(['A',Integer(2)])
          >>> [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

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

      Python

          >>> from sage.all import *
          >>> A2 = WeylCharacterRing("A2")
          >>> A2([Integer(1),Integer(0),Integer(0)]).cartan_type()
          ['A', 2]

    degree()

      Return the degree of `self`.

      This is the dimension of the associated module.

      EXAMPLES:

      Sage

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

      Python

          >>> from sage.all import *
          >>> B3 = WeylCharacterRing(['B',Integer(3)])
          >>> [B3(x).degree() for x in B3.fundamental_weights()]
          [7, 21, 8]

    dual()

      The involution that replaces a representation with its contragredient. (For Fusion rings, this is the conjugation map.)

      EXAMPLES:

      Sage

          sage: A3 = WeylCharacterRing("A3", style='coroots')
          sage: A3(1,0,0)^2
          A3(0,1,0) + A3(2,0,0)
          sage: (A3(1,0,0)^2).dual()
          A3(0,1,0) + A3(0,0,2)

      Python

          >>> from sage.all import *
          >>> A3 = WeylCharacterRing("A3", style='coroots')
          >>> A3(Integer(1),Integer(0),Integer(0))**Integer(2)
          A3(0,1,0) + A3(2,0,0)
          >>> (A3(Integer(1),Integer(0),Integer(0))**Integer(2)).dual()
          A3(0,1,0) + A3(0,0,2)

    exterior_power(k)

      Return the \(k\)-th exterior power of `self`.

      INPUT:

      - `k` – 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

          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)

      Python

          >>> from sage.all import *
          >>> B3 = WeylCharacterRing("B3",style='coroots')
          >>> spin = B3(Integer(0),Integer(0),Integer(1))
          >>> spin.exterior_power(Integer(6))
          B3(1,0,0) + B3(0,1,0)

    exterior_square()

      Return the exterior square of the character.

      EXAMPLES:

      Sage

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

      Python

          >>> from sage.all import *
          >>> A2 = WeylCharacterRing("A2",style='coroots')
          >>> A2(Integer(1),Integer(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

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

      Python

          >>> from sage.all import *
          >>> B2 = WeylCharacterRing("B2",style='coroots')
          >>> B2(Integer(1),Integer(0)).frobenius_schur_indicator()
           1
          >>> B2(Integer(0),Integer(1)).frobenius_schur_indicator()
           -1

    highest_weight()

      Return the parametrizing dominant weight of an irreducible character.

      This method is only available for basis elements.

      EXAMPLES:

      Sage

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

      Python

          >>> from sage.all import *
          >>> G2 = WeylCharacterRing("G2", style='coroots')
          >>> [x.highest_weight() for x in [G2(Integer(1),Integer(0)),G2(Integer(0),Integer(1))]]
          [(1, 0, -1), (2, -1, -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

          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

      Python

          >>> from sage.all import *
          >>> A2 = WeylCharacterRing("A2")
          >>> [f1,f2] = A2.fundamental_weights()
          >>> r1 = A2(f1)*A2(f2); r1
          A2(1,1,1) + A2(2,1,0)
          >>> r2 = A2(f1)**Integer(3); r2
          A2(1,1,1) + 2*A2(2,1,0) + A2(3,0,0)
          >>> 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

          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

      Python

          >>> from sage.all import *
          >>> A2 = WeylCharacterRing("A2",style='coroots')
          >>> rep = A2(Integer(1),Integer(0))**Integer(2)*A2(Integer(0),Integer(1))**Integer(2); rep
          2*A2(0,0) + A2(0,3) + 4*A2(1,1) + A2(3,0) + A2(2,2)
          >>> rep.invariant_degree()
          2

    is_irreducible()

      Return whether `self` is an irreducible character.

      EXAMPLES:

      Sage

          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

      Python

          >>> from sage.all import *
          >>> B3 = WeylCharacterRing(['B',Integer(3)])
          >>> [B3(x).is_irreducible() for x in B3.fundamental_weights()]
          [True, True, True]
          >>> 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

          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

      Python

          >>> from sage.all import *
          >>> B2 = WeylCharacterRing("B2",style='coroots')
          >>> rep = B2(Integer(1),Integer(1))**Integer(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)
          >>> rep.multiplicity(B2(Integer(0),Integer(2)))
          2

    symmetric_power(k)

      Return the \(k\)-th symmetric power of `self`.

      INPUT:

      - `k` – 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

          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)

      Python

          >>> from sage.all import *
          >>> B3 = WeylCharacterRing("B3",style='coroots')
          >>> spin = B3(Integer(0),Integer(0),Integer(1))
          >>> spin.symmetric_power(Integer(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

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

      Python

          >>> from sage.all import *
          >>> A2 = WeylCharacterRing("A2",style='coroots')
          >>> A2(Integer(1),Integer(0)).symmetric_square()
          A2(2,0)

    weight_multiplicities()

      Return the dictionary of weight multiplicities for the Weyl character `self`.

      The character does not have to be irreducible.

      EXAMPLES:

      Sage

          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}

      Python

          >>> from sage.all import *
          >>> B2 = WeylCharacterRing("B2",style='coroots')
          >>> B2(Integer(0),Integer(1)).weight_multiplicities()
          {(-1/2, -1/2): 1, (-1/2, 1/2): 1, (1/2, -1/2): 1, (1/2, 1/2): 1}

  adjoint_representation()

    Return the adjoint representation as an element of the WeylCharacterRing.

    EXAMPLES:

    Sage

        sage: G2 = WeylCharacterRing("G2",style='coroots')
        sage: G2.adjoint_representation()
        G2(0,1)

    Python

        >>> from sage.all import *
        >>> G2 = WeylCharacterRing("G2",style='coroots')
        >>> G2.adjoint_representation()
        G2(0,1)

  affine_reflect(wt, k=0)

    Return the reflection of wt in the hyperplane \(\theta\).

    Optionally, this also shifts by a multiple \(k\) of \(\theta\).

    INPUT:

    - `wt` – a weight

    - `k` – (optional) a positive integer

    EXAMPLES:

    Sage

        sage: B22 = FusionRing("B2",2)
        sage: fw = B22.fundamental_weights(); fw
        Finite family {1: (1, 0), 2: (1/2, 1/2)}
        sage: [B22.affine_reflect(x,2) for x in fw]
        [(2, 1), (3/2, 3/2)]

    Python

        >>> from sage.all import *
        >>> B22 = FusionRing("B2",Integer(2))
        >>> fw = B22.fundamental_weights(); fw
        Finite family {1: (1, 0), 2: (1/2, 1/2)}
        >>> [B22.affine_reflect(x,Integer(2)) for x in fw]
        [(2, 1), (3/2, 3/2)]

  ambient()

    Return the weight ring of `self`.

    EXAMPLES:

    Sage

        sage: WeylCharacterRing("A2").ambient()
        The Weight ring attached to The Weyl Character Ring of Type A2 with Integer Ring coefficients

    Python

        >>> from sage.all import *
        >>> WeylCharacterRing("A2").ambient()
        The Weight ring attached to The Weyl Character Ring of Type A2 with Integer Ring coefficients

  base_ring()

    Return the base ring of `self`.

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> R = WeylCharacterRing(['A',Integer(3)], base_ring = CC); R.base_ring()
        Complex Field with 53 bits of precision

  cartan_type()

    Return the Cartan type of `self`.

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> WeylCharacterRing("A2").cartan_type()
        ['A', 2]

  char_from_weights(mdict)

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

    INPUT:

    - `mdict` – 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

        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
        {(1, 3, 0): 1,
         (1, 0, 3): 1,
         (3, 1, 0): 1,
         (3, 0, 1): 1,
         (0, 1, 3): 1,
         (0, 3, 1): 1}
        sage: A2.char_from_weights(d)
        -A2(2,1,1) - A2(2,2,0) + A2(3,1,0)

    Python

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

  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`.

    See `WeightRing.Element.demazure()` and `sage.categories.classical_crystals.ClassicalCrystals.ParentMethods.demazure_character()`

    EXAMPLES:

    Sage

        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)

    Python

        >>> from sage.all import *
        >>> A2 = WeylCharacterRing("A2",style='coroots')
        >>> h = sum(A2.fundamental_weights()); h
        (2, 1, 0)
        >>> A2.demazure_character(h,word=[Integer(1),Integer(2)])
        a2(0,0) + a2(-2,1) + a2(2,-1) + a2(1,1) + a2(-1,2)
        >>> A2.demazure_character((Integer(1),Integer(1)),word=[Integer(1),Integer(2)])
        a2(0,0) + a2(-2,1) + a2(2,-1) + a2(1,1) + a2(-1,2)

  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

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

    Python

        >>> from sage.all import *
        >>> A2 = WeylCharacterRing("A2")
        >>> weights = sorted(A2(Integer(2),Integer(1),Integer(0)).weight_multiplicities().keys(), key=str); weights
        [(0, 1, 2), (0, 2, 1), (1, 0, 2), (1, 1, 1), (1, 2, 0), (2, 0, 1), (2, 1, 0)]
        >>> [A2.dot_reduce(x) for x in weights]
        [[0, (0, 0, 0)], [-1, (1, 1, 1)], [-1, (1, 1, 1)], [1, (1, 1, 1)], [0, (0, 0, 0)], [0, (0, 0, 0)], [1, (2, 1, 0)]]

  dynkin_diagram()

    Return the Dynkin diagram of `self`.

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> WeylCharacterRing("E7").dynkin_diagram()
                O 2
                |
                |
        O---O---O---O---O---O
        1   3   4   5   6   7
        E7

  extended_dynkin_diagram()

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

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> WeylCharacterRing("E7").extended_dynkin_diagram()
                    O 2
                    |
                    |
        O---O---O---O---O---O---O
        0   1   3   4   5   6   7
        E7~

  fundamental_weights()

    Return the fundamental weights.

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> WeylCharacterRing("G2").fundamental_weights()
        Finite family {1: (1, 0, -1), 2: (2, -1, -1)}

  highest_root()

    Return the highest root.

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> WeylCharacterRing("G2").highest_root()
         (2, -1, -1)

  irr_repr(hwv)

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

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> B3 = WeylCharacterRing("B3")
        >>> [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)']
        >>> B3 = WeylCharacterRing("B3", style='coroots')
        >>> [B3.irr_repr(v) for v in B3.fundamental_weights()]
        ['B3(1,0,0)', 'B3(0,1,0)', 'B3(0,0,1)']

  level(wt)

    Return the level of the weight, defined to be the value of the weight on the coroot associated with the highest root.

    EXAMPLES:

    Sage

        sage: R = FusionRing("F4",2); [R.level(x) for x in R.fundamental_weights()]
        [2, 3, 2, 1]
        sage: [CartanType("F4~").dual().a()[x] for x in [1..4]]
        [2, 3, 2, 1]

    Python

        >>> from sage.all import *
        >>> R = FusionRing("F4",Integer(2)); [R.level(x) for x in R.fundamental_weights()]
        [2, 3, 2, 1]
        >>> [CartanType("F4~").dual().a()[x] for x in (ellipsis_range(Integer(1),Ellipsis,Integer(4)))]
        [2, 3, 2, 1]

  lift()

    The embedding of `self` into its weight ring.

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> A2 = WeylCharacterRing("A2")
        >>> A2.lift
        Generic morphism:
          From: The Weyl Character Ring of Type A2 with Integer Ring coefficients
          To:   The Weight ring attached to The Weyl Character Ring of Type A2 with Integer Ring coefficients

    Sage

        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)

    [Python]

        >>> from sage.all import *
        >>> x = -A2(Integer(2),Integer(1),Integer(1)) - A2(Integer(2),Integer(2),Integer(0)) + A2(Integer(3),Integer(1),Integer(0))
        >>> 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

        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)

    Python

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

        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)

    [Python]

        >>> from sage.all import *
        >>> a2 = WeightRing(A2)
        >>> 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)

  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

        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)

    Python

        >>> from sage.all import *
        >>> A2 = WeylCharacterRing("A2")
        >>> v = A2._space([Integer(2),Integer(1),Integer(0)]); v
        (2, 1, 0)
        >>> 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 analogous calculation with symmetric Schur functions:

    Sage

        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

    [Python]

        >>> from sage.all import *
        >>> s = SymmetricFunctions(QQ).s()
        >>> s[Integer(2),Integer(1)].expand(Integer(3))
        x0^2*x1 + x0*x1^2 + x0^2*x2 + 2*x0*x1*x2 + x1^2*x2 + x0*x2^2 + x1*x2^2

  maximal_subgroup(ct)

    Return a branching rule or a list of branching rules.

    INPUT:

    - `ct` – the Cartan type of a maximal subgroup of `self`

    In rare cases where there is more than one maximal subgroup (up to outer automorphisms) with the given Cartan type, the function returns a list of branching rules.

    EXAMPLES:

    Sage

        sage: WeylCharacterRing("E7").maximal_subgroup("A2")
        miscellaneous branching rule E7 => A2
        sage: WeylCharacterRing("E7").maximal_subgroup("A1")
        [iii branching rule E7 => A1, iv branching rule E7 => A1]

    Python

        >>> from sage.all import *
        >>> WeylCharacterRing("E7").maximal_subgroup("A2")
        miscellaneous branching rule E7 => A2
        >>> WeylCharacterRing("E7").maximal_subgroup("A1")
        [iii branching rule E7 => A1, iv branching rule E7 => A1]

    For more information, see the related method `maximal_subgroups()`.

  maximal_subgroups()

    This method is only available if the Cartan type of `self` is irreducible and of rank no greater than 8. This method produces a list of the maximal subgroups of `self`, up to (possibly outer) automorphisms. Each line in the output gives the Cartan type of a maximal subgroup followed by a command that creates the branching rule.

    EXAMPLES:

    Sage

        sage: WeylCharacterRing("E6").maximal_subgroups()
        D5:branching_rule("E6","D5","levi")
        C4:branching_rule("E6","C4","symmetric")
        F4:branching_rule("E6","F4","symmetric")
        A2:branching_rule("E6","A2","miscellaneous")
        G2:branching_rule("E6","G2","miscellaneous")
        A2xG2:branching_rule("E6","A2xG2","miscellaneous")
        A1xA5:branching_rule("E6","A1xA5","extended")
        A2xA2xA2:branching_rule("E6","A2xA2xA2","extended")

    Python

        >>> from sage.all import *
        >>> WeylCharacterRing("E6").maximal_subgroups()
        D5:branching_rule("E6","D5","levi")
        C4:branching_rule("E6","C4","symmetric")
        F4:branching_rule("E6","F4","symmetric")
        A2:branching_rule("E6","A2","miscellaneous")
        G2:branching_rule("E6","G2","miscellaneous")
        A2xG2:branching_rule("E6","A2xG2","miscellaneous")
        A1xA5:branching_rule("E6","A1xA5","extended")
        A2xA2xA2:branching_rule("E6","A2xA2xA2","extended")

    Note that there are other embeddings of (for example \(A_2\) into \(E_6\) as nonmaximal subgroups. These embeddings may be constructed by composing branching rules through various subgroups.

    Once you know which maximal subgroup you are interested in, to create the branching rule, you may either paste the command to the right of the colon from the above output onto the command line, or alternatively invoke the related method `maximal_subgroup()`:

    Sage

        sage: branching_rule("E6","G2","miscellaneous")
        miscellaneous branching rule E6 => G2
        sage: WeylCharacterRing("E6").maximal_subgroup("G2")
        miscellaneous branching rule E6 => G2

    [Python]

        >>> from sage.all import *
        >>> branching_rule("E6","G2","miscellaneous")
        miscellaneous branching rule E6 => G2
        >>> WeylCharacterRing("E6").maximal_subgroup("G2")
        miscellaneous branching rule E6 => G2

    It is believed that the list of maximal subgroups is complete, except that some subgroups may be not be invariant under outer automorphisms. It is reasonable to want a list of maximal subgroups that is complete up to conjugation, but to obtain such a list you may have to apply outer automorphisms. The group of outer automorphisms modulo inner automorphisms is isomorphic to the group of symmetries of the Dynkin diagram, and these are available as branching rules. The following example shows that while a branching rule from \(D_4\) to \(A_1\times C_2\) is supplied, another different one may be obtained by composing it with the triality automorphism of \(D_4\):

    Sage

        sage: [D4,A1xC2]=[WeylCharacterRing(x,style='coroots') for x in ["D4","A1xC2"]]
        sage: fw = D4.fundamental_weights()
        sage: b = D4.maximal_subgroup("A1xC2")
        sage: [D4(fw).branch(A1xC2,rule=b) for fw in D4.fundamental_weights()]
        [A1xC2(1,1,0),
        A1xC2(2,0,0) + A1xC2(2,0,1) + A1xC2(0,2,0),
        A1xC2(1,1,0),
        A1xC2(2,0,0) + A1xC2(0,0,1)]
        sage: b1 = branching_rule("D4","D4","triality")*b
        sage: [D4(fw).branch(A1xC2,rule=b1) for fw in D4.fundamental_weights()]
        [A1xC2(1,1,0),
        A1xC2(2,0,0) + A1xC2(2,0,1) + A1xC2(0,2,0),
        A1xC2(2,0,0) + A1xC2(0,0,1),
        A1xC2(1,1,0)]

    Python

        >>> from sage.all import *
        >>> [D4,A1xC2]=[WeylCharacterRing(x,style='coroots') for x in ["D4","A1xC2"]]
        >>> fw = D4.fundamental_weights()
        >>> b = D4.maximal_subgroup("A1xC2")
        >>> [D4(fw).branch(A1xC2,rule=b) for fw in D4.fundamental_weights()]
        [A1xC2(1,1,0),
        A1xC2(2,0,0) + A1xC2(2,0,1) + A1xC2(0,2,0),
        A1xC2(1,1,0),
        A1xC2(2,0,0) + A1xC2(0,0,1)]
        >>> b1 = branching_rule("D4","D4","triality")*b
        >>> [D4(fw).branch(A1xC2,rule=b1) for fw in D4.fundamental_weights()]
        [A1xC2(1,1,0),
        A1xC2(2,0,0) + A1xC2(2,0,1) + A1xC2(0,2,0),
        A1xC2(2,0,0) + A1xC2(0,0,1),
        A1xC2(1,1,0)]

  one_basis()

    Return the index of 1 in `self`.

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> WeylCharacterRing("A3").one_basis()
        (0, 0, 0, 0)
        >>> WeylCharacterRing("A3").one()
        A3(0,0,0,0)

  positive_roots()

    Return the positive roots.

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> WeylCharacterRing("G2").positive_roots()
        [(0, 1, -1), (1, -2, 1), (1, -1, 0), (1, 0, -1), (1, 1, -2), (2, -1, -1)]

  product_on_basis(a, b)

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

    EXAMPLES:

    Sage

        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)

    Python

        >>> from sage.all import *
        >>> D4 = WeylCharacterRing(['D',Integer(4)])
        >>> spin_plus = D4(Integer(1)/Integer(2),Integer(1)/Integer(2),Integer(1)/Integer(2),Integer(1)/Integer(2))
        >>> spin_minus = D4(Integer(1)/Integer(2),Integer(1)/Integer(2),Integer(1)/Integer(2),-Integer(1)/Integer(2))
        >>> spin_plus * spin_minus # indirect doctest
        D4(1,0,0,0) + D4(1,1,1,0)
        >>> spin_minus * spin_plus
        D4(1,0,0,0) + D4(1,1,1,0)

    Uses the Brauer-Klimyk method.

  rank()

    Return the rank.

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> WeylCharacterRing("G2").rank()
        2

  retract()

    The partial inverse map from the weight ring into `self`.

    EXAMPLES:

    Sage

        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 A2 with Integer Ring coefficients
          To:   The Weyl Character Ring of Type A2 with Integer Ring coefficients

    Python

        >>> from sage.all import *
        >>> A2 = WeylCharacterRing("A2")
        >>> a2 = WeightRing(A2)
        >>> A2.retract
        Generic morphism:
          From: The Weight ring attached to The Weyl Character Ring of Type A2 with Integer Ring coefficients
          To:   The Weyl Character Ring of Type A2 with Integer Ring coefficients

    Sage

        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)

    [Python]

        >>> from sage.all import *
        >>> v = A2._space([Integer(3),Integer(1),Integer(0)]); v
        (3, 1, 0)
        >>> 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)
        >>> A2.retract(chi)
        -A2(2,1,1) - A2(2,2,0) + A2(3,1,0)

    The input should be invariant:

    Sage

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

    Python

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

        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

    [Python]

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

  simple_coroots()

    Return the simple coroots.

    EXAMPLES:

    Sage

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

    Python

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

  simple_roots()

    Return the simple roots.

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> WeylCharacterRing("G2").simple_roots()
        Finite family {1: (0, 1, -1), 2: (1, -2, 1)}

  some_elements()

    Return some elements of `self`.

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> WeylCharacterRing("A3").some_elements()
        [A3(1,0,0,0), A3(1,1,0,0), A3(1,1,1,0)]

  space()

    Return the weight space associated to `self`.

    EXAMPLES:

    Sage

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

    Python

        >>> from sage.all import *
        >>> WeylCharacterRing(['E',Integer(8)]).space()
        Ambient space of the Root system of type ['E', 8]

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

      sage: WeylCharacterRing("A2")(2,1,0).weight_multiplicities() # indirect doctest
      {(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}

  Python

      >>> from sage.all import *
      >>> WeylCharacterRing("A2")(Integer(2),Integer(1),Integer(0)).weight_multiplicities() # indirect doctest
      {(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}