doc edits and a new method in integrable_representations.py

src/doc/en/thematic_tutorials/lie/affine.rst

@@ -304,23 +304,7 @@ It is 1 if `\alpha` is a real root. For the affine Lie algebras
 that concern us now, the multiplicity of an imaginary root is
 the rank `\ell` of `\mathfrak{g}^\circ`.
 
-In Sage, many important things such as the roots, and Weyl group and are methods
-of the ambient space::
-
-    sage: V=RootSystem(['A',2,1]).ambient_space()
-    sage: V.positive_roots()
-    Disjoint union of Family (Positive real roots of type ['A', 2, 1], Positive imaginary roots of type ['A', 2, 1])
-    sage: V.simple_roots()
-    Finite family {0: -e[0] + e[2] + e['delta'], 1: e[0] - e[1], 2: e[1] - e[2]}
-    sage: V.weyl_group()
-    Weyl Group of type ['A', 2, 1] (as a matrix group acting on the ambient space)
-    sage: V.basic_imaginary_roots()[0]
-    e['delta']
-
-However it may be better for weights to have their parents to be
-the weight lattice instead of its ambient vector space. Therefore
-you may create all of the above vectors as parents of the weight
-lattice. In this case we recommend creating the lattice with the
+In most cases we recommend creating the weight lattice with the
 option ``extended=True``::
 
     sage: WL = RootSystem(['A',2,1]).weight_lattice(extended=True); WL
@@ -401,8 +385,8 @@ Coxeter number may be computed as follow::
     sage: sum(CartanType(['F',4,1]).dual().a()) # Dual Coxeter number
     9
 
-The Weyl Group and extended Affine Weyl Group
----------------------------------------------
+The Weyl Group
+--------------
 
 The ambient space of the root system comes with an
 (indefinite) inner product. The real roots have
@@ -413,6 +397,26 @@ the `\ell+1` reflections `s_i` with respect to the *simple positive roots*
 `\alpha_i` (`i=0,1,2,\cdots,\ell`) generate a Coxeter group.
 This is the *Weyl group* `W`.
 
+Illustrating how to use Sage to compute the action of W
+on the weight lattice::
+
+    sage: L=RootSystem("A2~").weight_lattice(extended=True)
+    sage: Lambda=L.fundamental_weights()
+    sage: delta=L.null_root()
+    sage: W = L.weyl_group(prefix="s")
+    sage: [s0,s1,s2]=W.simple_reflections()
+    sage: [(s0*s1*s2*s1).action(x)-x for x in Lambda]
+    [-2*Lambda[0] + Lambda[1] + Lambda[2] - delta,
+     -2*Lambda[0] + Lambda[1] + Lambda[2] - 2*delta,
+     -2*Lambda[0] + Lambda[1] + Lambda[2] - 2*delta]
+    sage: [s0.action(x) for x in Lambda]
+    [-Lambda[0] + Lambda[1] + Lambda[2] - delta, Lambda[1], Lambda[2]]
+    sage: s0.action(delta)
+    delta
+
+The extended affine Weyl Group
+------------------------------
+
 The subgroup `W^\circ` generated by `s_1,\cdots,s_\ell`
 is a finite Coxeter group that may be identified with
 the Weyl group of the finite-dimensional simple

src/doc/en/thematic_tutorials/lie/integrable.rst

@@ -89,8 +89,8 @@ lattice and `\rho` is the Weyl vector (:ref:`untwisted_affine`).
 Moreover if `\mu\in\text{supp}(V)` then `\Lambda-\mu`
 is an element of the root lattice `Q` ([Kac]_, Propositions 11.3 and 11.4).
 
-We organize the weight multiplicities into sequences called *strings*
-as follows. By [Kac]_, Proposition 11.3 or Corollary 11.9, for fixed `\mu`
+We organize the weight multiplicities into sequences called *string functions*
+or *strings* as follows. By [Kac]_, Proposition 11.3 or Corollary 11.9, for fixed `\mu`
 the function `m(\mu - k\delta)` of `k` is a increasing sequence.
 We adjust `\mu` by a multiple of `\delta` to the beginning
 of the positive part of the sequence. Thus we define
@@ -110,6 +110,33 @@ coefficients of a modular form; see also [Kac]_ Chapter 13.
 Sage methods for integrable representations
 -------------------------------------------
 
+In the following example, we work with the integrable representation
+with highest weight `2\Lambda_0` for `\widehat{\mathfrak{sl}}_2`,
+that is, `A_1^{(1)}. We compute the string functions. There are
+two, since there are two dominant multiple weights. One of them
+is the highest weight `2\Lambda_0`, and the other is `2\Lambda_1-\delta`.
+We apply the simple reflection `s_0` to the second, giving
+`2\Lambda_1-\delta`, a maximal weight that is not dominant.
+Then we compute the string function at this weight, which we see
+agrees with the string function for the corresponding dominant
+maximal weight.
+
+    sage: L = RootSystem("A1~").weight_lattice(extended=True)
+    sage: Lambda = L.fundamental_weights()
+    sage: delta = L.null_root()
+    sage: W = L.weyl_group(prefix="s")
+    sage: [s0,s1]=W.simple_reflections()
+    sage: V = IntegrableRepresentation(2*Lambda[0])
+    sage: V.strings()
+    {2*Lambda[0]: [1, 1, 3, 5, 10, 16, 28, 43, 70, 105, 161, 236],
+     2*Lambda[1] - delta: [1, 2, 4, 7, 13, 21, 35, 55, 86, 130, 196, 287]}
+     sage: [mw1,mw2] = V.dominant_maximal_weights(); mw1,mw2
+     (2*Lambda[0], 2*Lambda[1] - delta)
+     sage: s0.action(mw2)
+     2*Lambda[1] - delta
+     sage: [V.m(V.from_weight(s0.action(mw2)-k*delta)) for k in [0..10]]
+     [1, 2, 4, 7, 13, 21, 35, 55, 86, 130, 196]
+
 For further documentation, see the reference manual
 :class:`~sage.combinat.root_system.integrable_representations.IntegrableRepresentation`
 

src/sage/combinat/root_system/integrable_representations.py

@@ -850,6 +850,35 @@ def m(self, n):
         self._mdict[n] = ret
         return ret
 
+    def mult(self, mu):
+        """
+        INPUT:
+
+        - ``mu`` -- an element of the weight lattice
+
+        Returns the weight multiplicity of mu.
+
+        EXAMPLES:
+
+            sage: L = RootSystem("B3~").weight_lattice(extended=True)
+            sage: Lambda = L.fundamental_weights()
+            sage: delta = L.null_root()
+            sage: W = L.weyl_group(prefix="s")
+            sage: [s0,s1,s2,s3]=W.simple_reflections()
+            sage: V = IntegrableRepresentation(Lambda[0])
+            sage: weights = [w.action(Lambda[1]-4*delta) for w in [s1,s2,s0*s1*s2*s3]]; weights
+            [-Lambda[1] + Lambda[2] - 4*delta,
+            Lambda[1] - 4*delta,
+            -Lambda[1] + Lambda[2] - 4*delta]
+            sage: [V.mult(mu) for mu in weights]
+            [35, 35, 35]
+        """
+        try:
+            n = self.from_weight(mu)
+        except:
+            return 0
+        return self.m(n)
+
     @cached_method
     def dominant_maximal_weights(self):
         r"""