Ticket #14402: trac_14402-tensor_product_infinite_crystals-ts.patch

sage/categories/crystals.py

@@ -1118 +1118 @@
             from sage.categories.highest_weight_crystals import HighestWeightCrystals
             if index_set is None:
                 if HighestWeightCrystals() not in self.parent().categories():
-                    raise ValueError, "This is not a highest weight crystals!"
+                    raise ValueError("This is not a highest weight crystals!")
                 index_set = self.index_set()
             for i in index_set:
-                if self.epsilon(i) <> 0:
-                    self = self.e(i)
-                    hw = self.to_highest_weight(index_set = index_set)
+                next = self.e(i)
+                if next is not None:
+                    hw = next.to_highest_weight(index_set = index_set)
                     return [hw[0], [i] + hw[1]]
             return [self, []]
 
@@ -1162 +1162 @@
                     raise ValueError, "This is not a highest weight crystals!"
                 index_set = self.index_set()
             for i in index_set:
-                if self.phi(i) <> 0:
-                    self = self.f(i)
-                    lw = self.to_lowest_weight(index_set = index_set)
+                next = self.f(i)
+                if next is not None:
+                    lw = next.to_lowest_weight(index_set = index_set)
                     return [lw[0], [i] + lw[1]]
             return [self, []]
 

sage/combinat/crystals/generalized_young_walls.py

@@ -13 +13 @@
 introduced in [KS10]_ and designed to be a realization of the crystals
 `\mathcal{B}(\infty)` and `\mathcal{B}(\lambda)` in type `A_n^{(1)}`.
 
-.. WARNING::
-
-    Does not work with :func:`TensorProductOfCrystals`.
-
 REFERENCES:
 
 .. [KS10] J.-A. Kim and D.-U. Shin.

sage/combinat/crystals/highest_weight_crystals.py

@@ -21 +21 @@
 from sage.structure.parent import Parent
 from sage.combinat.root_system.cartan_type import CartanType
 from sage.combinat.crystals.letters import CrystalOfLetters
-from sage.combinat.crystals.tensor_product import TensorProductOfCrystals, CrystalOfWords
+from sage.combinat.crystals.tensor_product import TensorProductOfCrystals, \
+    TensorProductOfRegularCrystalsElement
 from sage.combinat.crystals.littelmann_path import CrystalOfLSPaths
 
 
@@ -100 +101 @@
     else:
         raise NotImplementedError
 
-class FiniteDimensionalHighestWeightCrystal_TypeE(CrystalOfWords):
+class FiniteDimensionalHighestWeightCrystal_TypeE(TensorProductOfCrystals):
     """
     Commonalities for all finite dimensional type E highest weight crystals
 
@@ -132 +133 @@
         Parent.__init__(self, category = ClassicalCrystals())
         self.module_generators = [self.module_generator()]
 
+    Element = TensorProductOfRegularCrystalsElement
 
     def module_generator(self):
         """

sage/combinat/crystals/tensor_product.py

@@ -3 +3 @@
 
 Main entry points:
 
-- :func:`TensorProductOfCrystals`
+- :class:`TensorProductOfCrystals`
 - :class:`CrystalOfTableaux`
 
+AUTHORS:
+
+- Anne Schilling, Nicolas Thiery (2007): Initial version
+- Ben Salisbury, Travis Scrimshaw (2013): Refactored tensor products to handle
+  non-regular crystals and created new subclass to take advantage of
+  the regularity
 """
 #*****************************************************************************
 #       Copyright (C) 2007 Anne Schilling <anne at math.ucdavis.edu>
@@ -25 +31 @@
 
 import operator
 from sage.misc.latex import latex
-from sage.misc.cachefunc import cached_method
+from sage.misc.cachefunc import cached_method, cached_in_parent_method
 from sage.structure.parent import Parent
 from sage.structure.element import Element, parent
+from sage.structure.global_options import GlobalOptions
 from sage.categories.category import Category
 from sage.categories.classical_crystals import ClassicalCrystals
+from sage.categories.regular_crystals import RegularCrystals
 from sage.combinat.root_system.cartan_type import CartanType
 from sage.combinat.cartesian_product import CartesianProduct
 from sage.combinat.combinat import CombinatorialObject
@@ -215 +223 @@
         l[k] = value
         return self.sibling(l)
 
-def TensorProductOfCrystals(*crystals, **options):
-    r"""
-    Tensor product of crystals.
-
-    Given two crystals `B` and `B'` of the same type,
-    one can form the tensor product `B \otimes B'`. As a set
-    `B \otimes B'` is the Cartesian product
-    `B \times B'`. The crystal operators `f_i` and
-    `e_i` act on `b \otimes b' \in B \otimes B'` as
-    follows:
-
-    .. math::
-
-      f_i(b \otimes b') = \begin{cases}
-      f_i(b) \otimes b' & \text{if $\varepsilon_i(b) \ge \varphi_i(b')$}\\
-      b \otimes f_i(b') & \text{otherwise}
-      \end{cases}
-
-    and
-
-    .. math::
-
-      e_i(b \otimes b') = \begin{cases}
-      b \otimes e_i(b') & \text{if $\varepsilon_i(b) \le \varphi_i(b')$}\\
-      e_i(b) \otimes b' & \text{otherwise.}
-      \end{cases}
-
-    Note that this is the opposite of Kashiwara's convention for tensor
-    products of crystals.
-
-    EXAMPLES:
-
-    We construct the type `A_2`-crystal generated by `2 \otimes 1 \otimes 1`::
-
-        sage: C = CrystalOfLetters(['A',2])
-        sage: T = TensorProductOfCrystals(C,C,C,generators=[[C(2),C(1),C(1)]])
-
-    It has `8` elements::
-
-        sage: T.list()
-        [[2, 1, 1], [2, 1, 2], [2, 1, 3], [3, 1, 3], [3, 2, 3], [3, 1, 1], [3, 1, 2], [3, 2, 2]]
-
-    One can also check the Cartan type of the crystal::
-
-        sage: T.cartan_type()
-        ['A', 2]
-
-    Other examples include crystals of tableaux (which internally are represented as tensor products
-    obtained by reading the tableaux columnwise)::
-
-        sage: C = CrystalOfTableaux(['A',3], shape=[1,1,0])
-        sage: D = CrystalOfTableaux(['A',3], shape=[1,0,0])
-        sage: T = TensorProductOfCrystals(C,D, generators=[[C(rows=[[1], [2]]), D(rows=[[1]])], [C(rows=[[2], [3]]), D(rows=[[1]])]])
-        sage: T.cardinality()
-        24
-        sage: TestSuite(T).run()
-        sage: T.module_generators
-        [[[[1], [2]], [[1]]], [[[2], [3]], [[1]]]]
-        sage: [x.weight() for x in T.module_generators]
-        [(2, 1, 0, 0), (1, 1, 1, 0)]
-
-    If no module generators are specified, we obtain the full tensor
-    product::
-
-        sage: C=CrystalOfLetters(['A',2])
-        sage: T=TensorProductOfCrystals(C,C)
-        sage: T.list()
-        [[1, 1], [1, 2], [1, 3], [2, 1], [2, 2], [2, 3], [3, 1], [3, 2], [3, 3]]
-        sage: T.cardinality()
-        9
-
-    For a tensor product of crystals without module generators, the
-    default implementation of module_generators contains all elements
-    in the tensor product of the crystals. If there is a subset of
-    elements in the tensor product that still generates the crystal,
-    this needs to be implemented for the specific crystal separately::
-
-        sage: T.module_generators.list()
-        [[1, 1], [1, 2], [1, 3], [2, 1], [2, 2], [2, 3], [3, 1], [3, 2], [3, 3]]
-
-    For classical highest weight crystals, it is also possible to list
-    all highest weight elements::
-
-        sage: C = CrystalOfLetters(['A',2])
-        sage: T = TensorProductOfCrystals(C,C,C,generators=[[C(2),C(1),C(1)],[C(1),C(2),C(1)]])
-        sage: T.highest_weight_vectors()
-        [[2, 1, 1], [1, 2, 1]]
-    """
-    crystals = tuple(crystals)
-    if "cartan_type" in options:
-        cartan_type = CartanType(options["cartan_type"])
-    else:
-        if len(crystals) == 0:
-            raise ValueError, "you need to specify the Cartan type if the tensor product list is empty"
-        else:
-            cartan_type = crystals[0].cartan_type()
-
-    if "generators" in options:
-        generators = tuple(tuple(x) if isinstance(x, list) else x for x in options["generators"])
-        return TensorProductOfCrystalsWithGenerators(crystals, generators=generators, cartan_type = cartan_type)
-    else:
-        return FullTensorProductOfCrystals(crystals, cartan_type = cartan_type)
-
-
 class CrystalOfWords(UniqueRepresentation, Parent):
     """
     Auxiliary class to provide a call method to create tensor product elements.
@@ -393 +297 @@
             return sum(q**(c[0].energy_function())*B.sum(B(P0(b.weight())) for b in c) for c in C)
         return B.sum(q**(b.energy_function())*B(P0(b.weight())) for b in self)
 
+TensorProductOfCrystalsOptions=GlobalOptions(name='tensor_product_of_crystals',
+    doc=r"""
+    Sets the global options for tensor products of crystals. The default is to
+    use the anti-Kashiwara convention.
 
-class TensorProductOfCrystalsWithGenerators(CrystalOfWords):
+    There are two conventions for how `e_i` and `f_i` act on tensor products,
+    and the difference between the two is the order of the tensor factors
+    are reversed. This affects both the input and output. See the example
+    below.
+    """,
+    end_doc=r"""
 
+    .. NOTE::
+
+        Changing the ``convention`` also changes how the input is handled.
+
+    .. WARNING::
+
+        Internally, the crystals are always stored using the anti-Kashiwara
+        convention.
+
+    If no parameters are set, then the function returns a copy of the
+    options dictionary.
+
+    EXAMPLES::
+
+        sage: C = CrystalOfLetters(['A',2])
+        sage: T = TensorProductOfCrystals(C,C)
+        sage: elt = T(C(1), C(2)); elt
+        [1, 2]
+        sage: TensorProductOfCrystals.global_options['convention'] = "Kashiwara"
+        sage: elt
+        [2, 1]
+        sage: T(C(1), C(2)) == elt
+        False
+        sage: T(C(2), C(1)) == elt
+        True
+        sage: TensorProductOfCrystals.global_options.reset()
+    """,
+    convention=dict(default="antiKashiwara",
+                    description='Sets the convention used for displaying/inputting tensor product of crystals',
+                    values=dict(antiKashiwara='use the anti-Kashiwara convention',
+                                Kashiwara='use the Kashiwara convention'),
+                    alias=dict(anti="antiKashiwara", opposite="antiKashiwara"),
+                    case_sensitive=False)
+)
+
+class TensorProductOfCrystals(CrystalOfWords):
+    r"""
+    Tensor product of crystals.
+
+    Given two crystals `B` and `B'` of the same Cartan type,
+    one can form the tensor product `B \otimes B^{\prime}`. As a set
+    `B \otimes B^{\prime}` is the Cartesian product
+    `B \times B^{\prime}`. The crystal operators `f_i` and
+    `e_i` act on `b \otimes b^{\prime} \in B \otimes B^{\prime}` as
+    follows:
+
+    .. MATH::
+
+        f_i(b \otimes b^{\prime}) = \begin{cases}
+        f_i(b) \otimes b^{\prime} & \text{if } \varepsilon_i(b) \geq
+        \varphi_i(b^{\prime}) \\
+        b \otimes f_i(b^{\prime}) & \text{otherwise}
+        \end{cases}
+
+    and
+
+    .. MATH::
+
+        e_i(b \otimes b^{\prime}) = \begin{cases}
+        e_i(b) \otimes b^{\prime} & \text{if } \varepsilon_i(b) >
+        \varphi_i(b^{\prime}) \\
+        b \otimes e_i(b^{\prime}) & \text{otherwise.}
+        \end{cases}
+
+    We also define:
+
+    .. MATH::
+
+        \begin{aligned}
+        \varphi_i(b \otimes b^{\prime}) & = \max\left( \varphi_i(b),
+        \varphi_i(b) + \varphi_i(b^{\prime}) - \varepsilon_i(b) \right)
+        \\ \varepsilon_i(b \otimes b^{\prime}) & = \max\left(
+        \varepsilon_i(b^{\prime}), \varepsilon_i(b^{\prime}) +
+        \varepsilon_i(b) - \varphi_i(b^{\prime}) \right).
+        \end{aligned}
+
+    .. NOTE::
+
+        This is the opposite of Kashiwara's convention for tensor
+        products of crystals.
+
+    Since tensor products are associative `(\mathcal{B} \otimes \mathcal{C})
+    \otimes \mathcal{D} \cong \mathcal{B} \otimes (\mathcal{C} \otimes
+    \mathcal{D})` via the natural isomorphism `(b \otimes c) \otimes d \mapsto
+    b \otimes (c \otimes d)`, we can generalizing this to arbitrary tensor
+    products. Thus consider `B_N \otimes \cdots \otimes B_1`, where each
+    `B_k` is an abstract crystal. The underlying set of the tensor product is
+    `B_N \times \cdots \times B_1`, while the crystal structure is given
+    as follows. Let `I` be the index set, and fix some `i \in I` and `b_N
+    \otimes \cdots \otimes b_1 \in B_N \otimes \cdots \otimes B_1`. Define
+
+    .. MATH::
+
+        a_i(k) := \varepsilon_i(b_k) - \sum_{j=1}^{k-1} \langle
+        \alpha_i^{\vee}, \mathrm{wt}(b_j) \rangle.
+
+    Then
+
+    .. MATH::
+
+        \begin{aligned}
+        \mathrm{wt}(b_N \otimes \cdots \otimes b_1) &=
+        \mathrm{wt}(b_N) + \cdots + \mathrm{wt}(b_1),
+        \\ \varepsilon_i(b_N \otimes \cdots \otimes b_1) &= \max_{1 \leq k
+        \leq n}\left( \sum_{j=1}^k \varepsilon_i(b_j) - \sum_{j=1}^{k-1}
+        \varphi_i(b_j) \right)
+        \\ & = \max_{1 \leq k \leq N}\bigl( a_i(k) \bigr),
+        \\ \varphi_i(b_N \otimes \cdots \otimes b_1) &= \max_{1 \leq k \leq N}
+        \left( \varphi_i(b_N) + \sum_{j=k}^{N-1} \big( \varphi_i(b_j) -
+        \varepsilon_i(b_{j+1}) \big) \right)
+        \\ & = \max_{1 \leq k \leq N}\bigl( \lambda_i + a_i(k) \bigr)
+        \end{aligned}
+
+    where `\lambda_i = \langle \alpha_i^{\vee}, \mathrm{wt}(b_N \otimes \cdots
+    \otimes b_1) \rangle`. Then for `k = 1, \ldots, N` the action of the
+    Kashiwara operators is determined as follows.
+
+    - If `a_i(k) > a_i(j)` for `1 \leq j < k` and `a_i(k) \geq a_i(j)`
+      for `k < j \leq N`:
+
+      .. MATH::
+
+          e_i(b_N \otimes \cdots \otimes b_1) = b_N \otimes \cdots \otimes
+          e_i b_k \otimes \cdots \otimes b_1.
+
+    - If `a_i(k) \geq a_i(j)` for `1 \leq j < k` and `a_i(k) > a_i(j)`
+      for `k < j \leq N`:
+
+      .. MATH::
+
+          f_i(b_N \otimes \cdots \otimes b_1) = b_N \otimes \cdots \otimes
+          f_i b_k \otimes \cdots \otimes b_1.
+
+    Note that this is just recursively applying the definition of the tensor
+    product on two crystals. Recall that `\langle \alpha_i^{\vee},
+    \mathrm{wt}(b_j) \rangle = \varphi_i(b_j) - \varepsilon_i(b_j)` by the
+    definition of a crystal.
+
+    .. RUBRIC:: Regular crystals
+
+    Now if all crystals `B_k` are regular crystals, all `\varepsilon_i` and
+    `\varphi_i` are non-negative and we can
+    define tensor product by the *signature rule*. We start by writing a word
+    in `+` and `-` as follows:
+
+    .. MATH::
+
+        \underbrace{- \cdots -}_{\varphi_i(b_N) \text{ times}} \quad
+        \underbrace{+ \cdots +}_{\varepsilon_i(b_N) \text{ times}}
+        \quad \cdots \quad
+        \underbrace{- \cdots -}_{\varphi_i(b_1) \text{ times}} \quad
+        \underbrace{+ \cdots +}_{\varepsilon_i(b_1) \text{ times}},
+
+    and then canceling ordered pairs of `+-` until the word is in the reduced
+    form:
+
+    .. MATH::
+
+        \underbrace{- \cdots -}_{\varphi_i \text{ times}} \quad
+        \underbrace{+ \cdots +}_{\varepsilon_i \text{ times}}.
+
+    Here `e_i` acts on the factor corresponding to the leftmost `+` and `f_i`
+    on the factor corresponding to the rightmost `-`. If there is no `+` or
+    `-` respectively, then the result is `0` (``None``).
+
+    EXAMPLES:
+
+    We construct the type `A_2`-crystal generated by `2 \otimes 1 \otimes 1`::
+
+        sage: C = CrystalOfLetters(['A',2])
+        sage: T = TensorProductOfCrystals(C,C,C,generators=[[C(2),C(1),C(1)]])
+
+    It has `8` elements::
+
+        sage: T.list()
+        [[2, 1, 1], [2, 1, 2], [2, 1, 3], [3, 1, 3], [3, 2, 3], [3, 1, 1], [3, 1, 2], [3, 2, 2]]
+
+    One can also check the Cartan type of the crystal::
+
+        sage: T.cartan_type()
+        ['A', 2]
+
+    Other examples include crystals of tableaux (which internally are
+    represented as tensor products obtained by reading the tableaux
+    columnwise)::
+
+        sage: C = CrystalOfTableaux(['A',3], shape=[1,1,0])
+        sage: D = CrystalOfTableaux(['A',3], shape=[1,0,0])
+        sage: T = TensorProductOfCrystals(C,D, generators=[[C(rows=[[1], [2]]), D(rows=[[1]])], [C(rows=[[2], [3]]), D(rows=[[1]])]])
+        sage: T.cardinality()
+        24
+        sage: TestSuite(T).run()
+        sage: T.module_generators
+        [[[[1], [2]], [[1]]], [[[2], [3]], [[1]]]]
+        sage: [x.weight() for x in T.module_generators]
+        [(2, 1, 0, 0), (1, 1, 1, 0)]
+
+    If no module generators are specified, we obtain the full tensor
+    product::
+
+        sage: C = CrystalOfLetters(['A',2])
+        sage: T = TensorProductOfCrystals(C,C)
+        sage: T.list()
+        [[1, 1], [1, 2], [1, 3], [2, 1], [2, 2], [2, 3], [3, 1], [3, 2], [3, 3]]
+        sage: T.cardinality()
+        9
+
+    For a tensor product of crystals without module generators, the
+    default implementation of ``module_generators`` contains all elements
+    in the tensor product of the crystals. If there is a subset of
+    elements in the tensor product that still generates the crystal,
+    this needs to be implemented for the specific crystal separately::
+
+        sage: T.module_generators.list()
+        [[1, 1], [1, 2], [1, 3], [2, 1], [2, 2], [2, 3], [3, 1], [3, 2], [3, 3]]
+
+    For classical highest weight crystals, it is also possible to list
+    all highest weight elements::
+
+        sage: C = CrystalOfLetters(['A',2])
+        sage: T = TensorProductOfCrystals(C,C,C,generators=[[C(2),C(1),C(1)],[C(1),C(2),C(1)]])
+        sage: T.highest_weight_vectors()
+        [[2, 1, 1], [1, 2, 1]]
+
+    Examples with non-regular and infinite crystals (these did not work
+    before :trac:`14402`)::
+
+        sage: B = InfinityCrystalOfTableaux(['D',10])
+        sage: T = TensorProductOfCrystals(B,B)
+        sage: T
+        Full tensor product of the crystals
+        [The infinity crystal of tableaux of type ['D', 10],
+         The infinity crystal of tableaux of type ['D', 10]]
+
+        sage: B = CrystalOfGeneralizedYoungWalls(15)
+        sage: T = TensorProductOfCrystals(B,B,B)
+        sage: T
+        Full tensor product of the crystals
+        [Crystal of generalized Young walls of type ['A', 15, 1],
+         Crystal of generalized Young walls of type ['A', 15, 1],
+         Crystal of generalized Young walls of type ['A', 15, 1]]
+
+        sage: La = RootSystem(['A',2,1]).weight_lattice().fundamental_weights()
+        sage: B = HighestWeightCrystalOfGYW(2,La[0]+La[1])
+        sage: C = HighestWeightCrystalOfGYW(2,2*La[2])
+        sage: D = HighestWeightCrystalOfGYW(2,3*La[0]+La[2])
+        sage: T = TensorProductOfCrystals(B,C,D)
+        sage: T
+        Full tensor product of the crystals
+        [Highest weight crystal of generalized Young walls of Cartan type ['A', 2, 1] and highest weight Lambda[0] + Lambda[1].,
+         Highest weight crystal of generalized Young walls of Cartan type ['A', 2, 1] and highest weight 2*Lambda[2].,
+         Highest weight crystal of generalized Young walls of Cartan type ['A', 2, 1] and highest weight 3*Lambda[0] + Lambda[2].]
+
+    There is also a global option for setting the convention (by default Sage
+    uses anti-Kashiwara)::
+
+        sage: C = CrystalOfLetters(['A',2])
+        sage: T = TensorProductOfCrystals(C,C)
+        sage: elt = T(C(1), C(2)); elt
+        [1, 2]
+        sage: TensorProductOfCrystals.global_options['convention'] = "Kashiwara"
+        sage: elt
+        [2, 1]
+        sage: TensorProductOfCrystals.global_options.reset()
+    """
+    @staticmethod
+    def __classcall_private__(cls, *crystals, **options):
+        """
+        Create the correct parent object.
+
+        EXAMPLES::
+
+            sage: C = CrystalOfLetters(['A',2])
+            sage: T = TensorProductOfCrystals(C, C)
+            sage: T2 = TensorProductOfCrystals(C, C)
+            sage: T is T2
+            True
+            sage: B = InfinityCrystalOfTableaux(['A',2])
+            sage: T = TensorProductOfCrystals(B, B)
+        """
+        crystals = tuple(crystals)
+        if "cartan_type" in options:
+            cartan_type = CartanType(options["cartan_type"])
+        else:
+            if len(crystals) == 0:
+                raise ValueError("you need to specify the Cartan type if the tensor product list is empty")
+            else:
+                cartan_type = crystals[0].cartan_type()
+
+        if "generators" in options:
+            generators = tuple(tuple(x) if isinstance(x, list) else x for x in options["generators"])
+
+            if all(c in RegularCrystals() for c in crystals):
+                return TensorProductOfRegularCrystalsWithGenerators(crystals, generators, cartan_type)
+            return TensorProductOfCrystalsWithGenerators(crystals, generators, cartan_type)
+
+        if all(c in RegularCrystals() for c in crystals):
+            return FullTensorProductOfRegularCrystals(crystals, cartan_type=cartan_type)
+        return FullTensorProductOfCrystals(crystals, cartan_type=cartan_type)
+
+    global_options = TensorProductOfCrystalsOptions
+
+    def _element_constructor_(self, *crystalElements):
+        """
+        EXAMPLES::
+
+            sage: C = CrystalOfLetters(['A',2])
+            sage: T = TensorProductOfCrystals(C,C)
+            sage: T(1,1)
+            [1, 1]
+            sage: _.parent()
+            Full tensor product of the crystals [The crystal of letters for type ['A', 2], The crystal of letters for type ['A', 2]]
+            sage: T = TensorProductOfCrystals(C,C,C,generators=[[C(2),C(1),C(1)]])
+            sage: T(C(2), C(1), C(1))
+            [2, 1, 1]
+        """
+        if self.global_options['convention'] == "Kashiwara":
+            crystalElements = reversed(crystalElements)
+        return self.element_class(self, list(crystalElements))
+
+class TensorProductOfCrystalsWithGenerators(TensorProductOfCrystals):
+    """
+    Tensor product of crystals with a generating set.
+    """
     def __init__(self, crystals, generators, cartan_type):
         """
         EXAMPLES::
@@ -408 +645 @@
         assert isinstance(generators, tuple)
         category = Category.meet([crystal.category() for crystal in crystals])
         Parent.__init__(self, category = category)
-        self.rename("The tensor product of the crystals %s"%(crystals,))
         self.crystals = crystals
         self._cartan_type = cartan_type
         self.module_generators = [ self(*x) for x in generators ]
 
+    def _repr_(self):
+        """
+        Return a string representation of ``self``.
 
-class FullTensorProductOfCrystals(CrystalOfWords):
+        EXAMPLES::
+
+            sage: C = CrystalOfLetters(['A',2])
+            sage: TensorProductOfCrystals(C,C,generators=[[C(2),C(1)]])
+            The tensor product of the crystals [The crystal of letters for type ['A', 2], The crystal of letters for type ['A', 2]]
+        """
+        if self.global_options['convention'] == "Kashiwara":
+            st = repr(list(reversed(self.crystals)))
+        else:
+            st = repr(list(self.crystals))
+        return "The tensor product of the crystals %s"%st
+
+class FullTensorProductOfCrystals(TensorProductOfCrystals):
+    """
+    Full tensor product of crystals.
+    """
     def __init__(self, crystals, **options):
         """
         TESTS::
@@ -429 +683 @@
         crystals = list(crystals)
         category = Category.meet([crystal.category() for crystal in crystals])
         Parent.__init__(self, category = category)
-        self.rename("Full tensor product of the crystals %s"%(crystals,))
         self.crystals = crystals
         if options.has_key('cartan_type'):
             self._cartan_type = CartanType(options['cartan_type'])
@@ -441 +694 @@
         self.cartesian_product = CartesianProduct(*self.crystals)
         self.module_generators = self
 
+    def _repr_(self):
+        """
+        Return a string representation of ``self``.
+
+        EXAMPLES::
+
+            sage: C = CrystalOfLetters(['A',2])
+            sage: TensorProductOfCrystals(C,C)
+            Full tensor product of the crystals [The crystal of letters for type ['A', 2], The crystal of letters for type ['A', 2]]
+        """
+        if self.global_options['convention'] == "Kashiwara":
+            st = repr(reversed(self.crystals))
+        else:
+            st = repr(self.crystals)
+        return "Full tensor product of the crystals %s"%st
+
     # TODO: __iter__ and cardinality should be inherited from EnumeratedSets().CartesianProducts()
     def __iter__(self):
         """
@@ -460 +729 @@
 
     def cardinality(self):
         """
+        Return the cardinality of ``self``.
+
         EXAMPLES::
 
             sage: C = CrystalOfLetters(['A',2])
@@ -469 +740 @@
         """
         return self.cartesian_product.cardinality()
 
-
-
 class TensorProductOfCrystalsElement(ImmutableListWithParent):
     r"""
-    A class for elements of tensor products of crystals
+    A class for elements of tensor products of crystals.
     """
+    def _repr_(self):
+        """
+        Return a string representation of ``self``.
+
+        EXAMPLES::
+
+            sage: C = CrystalOfLetters(['A',3])
+            sage: T = TensorProductOfCrystals(C,C)
+            sage: T(C(1),C(2))
+            [1, 2]
+        """
+        if self.parent().global_options['convention'] == "Kashiwara":
+            return repr(list(reversed(self._list)))
+        return repr(self._list)
+
+    def _latex_(self):
+        r"""
+        Return latex code for ``self``.
+
+        EXAMPLES::
+
+            sage: C = CrystalOfLetters(["A",2])
+            sage: D = CrystalOfTableaux(["A",2], shape=[2])
+            sage: E = TensorProductOfCrystals(C,D)
+            sage: latex(E.module_generators[0])
+            1 \otimes {\def\lr#1{\multicolumn{1}{|@{\hspace{.6ex}}c@{\hspace{.6ex}}|}{\raisebox{-.3ex}{$#1$}}}
+            \raisebox{-.6ex}{$\begin{array}[b]{*{2}c}\cline{1-2}
+            \lr{1}&\lr{1}\\\cline{1-2}
+            \end{array}$}
+            }
+        """
+        return ' \otimes '.join(latex(c) for c in self)
 
     def __lt__(self, other):
         """
         Non elements of the crystal are incomparable with elements of the crystal
-        (or should it return NotImplemented?)
+        (or should it return NotImplemented?).
 
         Comparison of two elements of this crystal:
-         - different length: incomparable
-         - otherwise lexicographicaly, considering self[i] and other[i]
-           as incomparable if self[i] < other[i] returns NotImplemented
+
+        - different length: incomparable
+        - otherwise lexicographicaly, considering ``self[i]`` and ``other[i]``
+          as incomparable if ``self[i] < other[i]`` returns NotImplemented
         """
         if parent(self) is not parent(other):
             return False
@@ -497 +799 @@
                 return False
         return False
 
+    def weight(self):
+        r"""
+        Return the weight of ``self``.
+
+        EXAMPLES::
+
+            sage: B = InfinityCrystalOfTableaux("A3")
+            sage: T = TensorProductOfCrystals(B,B)
+            sage: b1 = B.highest_weight_vector().f_string([2,1,3])
+            sage: b2 = B.highest_weight_vector().f(1)
+            sage: t = T(b2, b1)
+            sage: t
+            [[[1, 1, 1, 2], [2, 2], [3]], [[1, 1, 1, 1, 2], [2, 2, 4], [3]]]
+            sage: t.weight()
+            -2*alpha[1] - alpha[2] - alpha[3]
+        """
+        return sum(self[i].weight() for i in range(len(self)))
+
+    def epsilon(self, i):
+        r"""
+        Return `\varepsilon_i` of ``self``.
+
+        INPUT:
+
+        - ``i`` -- An element of the index set
+
+        EXAMPLES::
+
+            sage: B = InfinityCrystalOfTableaux("G2")
+            sage: T = TensorProductOfCrystals(B,B)
+            sage: b1 = B.highest_weight_vector().f(2)
+            sage: b2 = B.highest_weight_vector().f_string([2,2,1])
+            sage: t = T(b2, b1)
+            sage: [t.epsilon(i) for i in B.index_set()]
+            [0, 3]
+        """
+        return max(self._sig(i, k) for k in range(1, len(self)+1))
+
+    def phi(self, i):
+        r"""
+        Return `\varphi_i` of ``self``.
+
+        INPUT:
+
+        - ``i`` -- An element of the index set
+
+        EXAMPLES::
+
+            sage: La = RootSystem(['A',2,1]).weight_lattice().fundamental_weights()
+            sage: B = HighestWeightCrystalOfGYW(2,La[0]+La[1])
+            sage: T = TensorProductOfCrystals(B,B)
+            sage: b1 = B.highest_weight_vector().f_string([1,0])
+            sage: b2 = B.highest_weight_vector().f_string([0,1])
+            sage: t = T(b2, b1)
+            sage: [t.phi(i) for i in B.index_set()]
+            [1, 1, 4]
+        """
+        P = self[-1].parent().weight_lattice_realization()
+        h = P.simple_coroots()
+        omega = P(self.weight()).scalar(h[i])
+        return max([omega + self._sig(i, k) for k in range(len(self))])
+
+    @cached_in_parent_method
+    def _sig(self,i,k):
+        r"""
+        Return `a_i(k)` of ``self``.
+
+        The value `a_i(k)` of a crystal `b = b_N \otimes \cdots \otimes b_1`
+        is defined as:
+
+        .. MATH::
+
+            a_i(k) = \varepsilon_i(b_k) - \sum_{j=1}^{k-1} \langle h_i,
+            \mathrm{wt}(b_j) \rangle
+
+        where `\mathrm{wt}` is the :meth:`weight` of `b_j`.
+
+        INPUT:
+
+        - ``i`` -- An element of the index set
+
+        - ``k`` -- The (1-based) index of the tensor factor of ``self``
+
+        EXAMPLES::
+
+            sage: B = CrystalOfGeneralizedYoungWalls(3)
+            sage: T = TensorProductOfCrystals(B,B)
+            sage: b1 = B.highest_weight_vector().f_string([0,3,1])
+            sage: b2 = B.highest_weight_vector().f_string([3,2,1,0,2,3])
+            sage: t = T(b1, b2)
+            sage: [[t._sig(i,k) for k in range(1,len(t)+1)] for i in B.index_set()]
+            [[0, -1], [0, 0], [0, 1], [1, 2]]
+        """
+        if k == 1:
+            return self[-1].epsilon(i)
+        return self._sig(i, k-1) + self[-k].epsilon(i) - self[-k+1].phi(i)
+
+    def e(self,i):
+        r"""
+        Return the action of `e_i` on ``self``.
+
+        INPUT:
+
+        - ``i`` -- An element of the index set
+
+        EXAMPLES::
+
+            sage: B = InfinityCrystalOfTableaux("D4")
+            sage: T = TensorProductOfCrystals(B,B)
+            sage: b1 = B.highest_weight_vector().f_string([1,4,3])
+            sage: b2 = B.highest_weight_vector().f_string([2,2,3,1,4])
+            sage: t = T(b2, b1)
+            sage: t.e(1)
+            [[[1, 1, 1, 1, 1], [2, 2, 3, -3], [3]], [[1, 1, 1, 1, 2], [2, 2, 2], [3, -3]]]
+            sage: t.e(2)
+            sage: t.e(3)
+            [[[1, 1, 1, 1, 1, 2], [2, 2, 3, -4], [3]], [[1, 1, 1, 1, 2], [2, 2, 2], [3, -3]]]
+            sage: t.e(4)
+            [[[1, 1, 1, 1, 1, 2], [2, 2, 3, 4], [3]], [[1, 1, 1, 1, 2], [2, 2, 2], [3, -3]]]
+        """
+        N = len(self) + 1
+        for k in range(1, N):
+            if all(self._sig(i,k) > self._sig(i,j) for j in range(1, k)) and \
+                    all(self._sig(i,k) >= self._sig(i,j) for j in range(k+1, N)):
+                crystal = self[-k].e(i)
+                if crystal is None:
+                    return None
+                return self.set_index(-k, crystal)
+        return None
+
+    def f(self,i):
+        r"""
+        Return the action of `f_i` on ``self``.
+
+        INPUT:
+
+        - ``i`` -- An element of the index set
+
+        EXAMPLES::
+
+            sage: La = RootSystem(['A',3,1]).weight_lattice().fundamental_weights()
+            sage: B = HighestWeightCrystalOfGYW(3,La[0])
+            sage: T = TensorProductOfCrystals(B,B,B)
+            sage: b1 = B.highest_weight_vector().f_string([0,3])
+            sage: b2 = B.highest_weight_vector().f_string([0])
+            sage: b3 = B.highest_weight_vector()
+            sage: t = T(b3, b2, b1)
+            sage: t.f(0)
+            [[[0]], [[0]], [[0, 3]]]
+            sage: t.f(1)
+            [[], [[0]], [[0, 3], [1]]]
+            sage: t.f(2)
+            [[], [[0]], [[0, 3, 2]]]
+            sage: t.f(3)
+            [[], [[0, 3]], [[0, 3]]]
+        """
+        N = len(self) + 1
+        for k in range(1, N):
+            if all(self._sig(i,k) >= self._sig(i,j) for j in range(1, k)) and \
+                    all(self._sig(i,k) > self._sig(i,j) for j in range(k+1, N)):
+                crystal = self[-k].f(i)
+                if crystal is None:
+                    return None
+                return self.set_index(-k, crystal)
+        return None
+
+class TensorProductOfRegularCrystalsElement(TensorProductOfCrystalsElement):
+    """
+    Element class for a tensor product of regular crystals.
+
+    TESTS::
+
+        sage: C = CrystalOfLetters(['A',2])
+        sage: T = TensorProductOfCrystals(C, C)
+        sage: elt = T(C(1), C(2))
+        sage: from sage.combinat.crystals.tensor_product import TensorProductOfRegularCrystalsElement
+        sage: isinstance(elt, TensorProductOfRegularCrystalsElement)
+        True
+    """
     def e(self, i):
         """
-        Returns the action of `e_i` on self.
+        Return the action of `e_i` on ``self``.
 
         EXAMPLES::
 
@@ -512 +993 @@
             sage: T(C(2),C(2)).e(1) == T(C(1),C(2))
             True
         """
-        assert i in self.index_set()
+        if i not in self.index_set():
+            raise ValueError("i must be in the index set")
         position = self.positions_of_unmatched_plus(i)
         if position == []:
             return None
@@ -521 +1003 @@
 
     def weight(self):
         """
-        Returns the weight of self.
+        Return the weight of ``self``.
 
         EXAMPLES::
 
@@ -537 +1019 @@
 
     def f(self, i):
         """
-        Returns the action of `f_i` on self.
+        Return the action of `f_i` on ``self``.
 
         EXAMPLES::
 
@@ -550 +1032 @@
             sage: T(C(2),C(1)).f(1) is None
             True
         """
-        assert i in self.index_set()
+        if i not in self.index_set():
+            raise ValueError("i must be in the index set")
         position = self.positions_of_unmatched_minus(i)
         if position == []:
             return None
@@ -558 +1041 @@
         return self.set_index(k, self[k].f(i))
 
     def phi(self, i):
-        """
+        r"""
+        Return `\varphi_i` of ``self``.
+
         EXAMPLES::
 
             sage: C = CrystalOfLetters(['A',5])
@@ -582 +1067 @@
         return height
 
     def epsilon(self, i):
-        """
+        r"""
+        Return `\varepsilon_i` of ``self``.
+
         EXAMPLES::
 
             sage: C = CrystalOfLetters(['A',5])
@@ -654 +1141 @@
         l.reverse()
         return [len(self)-1-l[j] for j in range(len(l))]
 
-    def _latex_(self):
-        """
-        Returns latex code for self.
-
-        EXAMPLES::
-
-            sage: C = CrystalOfLetters(["A",2])
-            sage: D = CrystalOfTableaux(["A",2], shape=[2])
-            sage: E = TensorProductOfCrystals(C,D)
-            sage: print E.module_generators[0]._latex_()
-            1\otimes{\def\lr#1{\multicolumn{1}{|@{\hspace{.6ex}}c@{\hspace{.6ex}}|}{\raisebox{-.3ex}{$#1$}}}
-            \raisebox{-.6ex}{$\begin{array}[b]{*{2}c}\cline{1-2}
-            \lr{1}&\lr{1}\\\cline{1-2}
-            \end{array}$}
-            }
-        """
-        return '\otimes'.join(latex(c) for c in self)
-
     def energy_function(self):
         r"""
-        Returns the energy function of `self`.
+        Return the energy function of ``self``.
 
         INPUT:
 
@@ -688 +1157 @@
 
         REFERENCES:
 
-            .. [SchillingTingley2011] A. Schilling, P. Tingley.
-               Demazure crystals, Kirillov-Reshetikhin crystals, and the energy function.
-               preprint arXiv:1104.2359
+        .. [SchillingTingley2011] A. Schilling, P. Tingley.
+           Demazure crystals, Kirillov-Reshetikhin crystals, and the energy
+           function. Electronic Journal of Combinatorics. **19(2)**. 2012.
+           :arXiv:`1104.2359`
 
         EXAMPLES::
 
@@ -727 +1197 @@
             sage: t.energy_function()
             Traceback (most recent call last):
             ...
-            AssertionError: All crystals in the tensor product need to be perfect of the same level
+            ValueError: All crystals in the tensor product need to be perfect of the same level
         """
         C = self.parent().crystals[0]
         ell = ceil(C.s()/C.cartan_type().c()[C.r()])
-        assert all(ell == K.s()/K.cartan_type().c()[K.r()] for K in self.parent().crystals), \
-            "All crystals in the tensor product need to be perfect of the same level"
+        if any(ell != K.s()/K.cartan_type().c()[K.r()] for K in self.parent().crystals):
+            raise ValueError("All crystals in the tensor product need to be perfect of the same level")
         t = self.parent()(*[K.module_generator() for K in self.parent().crystals])
         d = t.affine_grading()
         return d - self.affine_grading()
@@ -823 +1293 @@
             sage: y.e_string_to_ground_state()
             ()
         """
-        assert self.parent().crystals[0].__module__ == 'sage.combinat.crystals.kirillov_reshetikhin', \
-            "All crystals in the tensor product need to be Kirillov-Reshetikhin crystals"
+        if self.parent().crystals[0].__module__ != 'sage.combinat.crystals.kirillov_reshetikhin':
+            raise ValueError("All crystals in the tensor product need to be Kirillov-Reshetikhin crystals")
         I = self.index_set()
         I.remove(0)
         ell = max(ceil(K.s()/K.cartan_type().c()[K.r()]) for K in self.parent().crystals)
@@ -837 +1307 @@
 
 CrystalOfWords.Element = TensorProductOfCrystalsElement
 
+class FullTensorProductOfRegularCrystals(FullTensorProductOfCrystals):
+    """
+    Full tensor product of regular crystals.
+    """
+    Element = TensorProductOfRegularCrystalsElement
+
+class TensorProductOfRegularCrystalsWithGenerators(TensorProductOfCrystalsWithGenerators):
+    """
+    Tensor product of regular crystals with a generating set.
+    """
+    Element = TensorProductOfRegularCrystalsElement
+
+#########################################################
+## Crystal of tableaux
 
 class CrystalOfTableaux(CrystalOfWords):
     r"""
@@ -844 +1328 @@
 
     INPUT:
 
-     - ``cartan_type`` -- a Cartan type
-     - ``shape`` -- a partition of length at most ``cartan_type.rank()``
-     - ``shapes`` -- a list of such partitions
+    - ``cartan_type`` -- a Cartan type
+    - ``shape`` -- a partition of length at most ``cartan_type.rank()``
+    - ``shapes`` -- a list of such partitions
 
     This constructs a classical crystal with the given Cartan type and
     highest weight(s) corresponding to the given shape(s).
 
     If the type is `D_r`, the shape is permitted to have a negative
-    value in the `r`-th position. Thus if shape=`[s_1,\dots,s_r]` then
-    `s_r` may be negative but in any case `s_1 \ge \cdots \ge s_{r-1}
-    \ge |s_r|`. This crystal is related to that of shape
-    `[s_1,\dots,|s_r|]` by the outer automorphism of `SO(2r)`.
+    value in the `r`-th position. Thus if the shape equals `[s_1,\ldots,s_r]`,
+    then `s_r` may be negative but in any case `s_1 \geq \cdots \geq s_{r-1}
+    \geq |s_r|`. This crystal is related to that of shape
+    `[s_1,\ldots,|s_r|]` by the outer automorphism of `SO(2r)`.
 
     If the type is `D_r` or `B_r`, the shape is permitted to be of
     length `r` with all parts of half integer value. This corresponds
@@ -864 +1348 @@
     have this property.
 
     Crystals of tableaux are constructed using an embedding into
-    tensor products following Kashiwara and Nakashima [Kashiwara,
-    Masaki; Nakashima, Toshiki, *Crystal graphs for representations of
-    the q-analogue of classical Lie algebras*, J. Algebra 165 (1994),
-    no. 2, 295-345.]. Sage's tensor product rule for crystals differs
-    from that of Kashiwara and Nakashima by reversing the order of the
-    tensor factors. Sage produces the same crystals of tableaux as
-    Kashiwara and Nakashima. With Sage's convention, the tensor
-    product of crystals is the same as the monoid operation on
+    tensor products following Kashiwara and Nakashima [KN94]_. Sage's tensor
+    product rule for crystals differs from that of Kashiwara and Nakashima
+    by reversing the order of the tensor factors. Sage produces the same
+    crystals of tableaux as Kashiwara and Nakashima. With Sage's convention,
+    the tensor product of crystals is the same as the monoid operation on
     tableaux and hence the plactic monoid.
 
-    .. seealso:: :mod:`sage.combinat.crystals.crystals` for general help on
-        crystals, and in particular plotting and LaTeX output.
+    .. SEEALSO::
+
+        :mod:`sage.combinat.crystals.crystals` for general help on
+        crystals, and in particular plotting and `\LaTeX` output.
 
     EXAMPLES:
 
     We create the crystal of tableaux for type `A_2`, with
-    highest weight given by the partition [2,1,1]::
+    highest weight given by the partition `[2,1,1]`::
 
         sage: T = CrystalOfTableaux(['A',3], shape = [2,1,1])
 
@@ -912 +1395 @@
         sage: Tab(columns=[[3,1],[4,2]])
         [[1, 2], [3, 4]]
 
-    FIXME:
+    .. TODO::
 
-     - do we want to specify the columns increasingly or
-       decreasingly. That is, should this be Tab(columns = [[1,3],[2,4]])
-     - make this fully consistent with :func:`~sage.combinat.tableau.Tableau`!
+        FIXME:
+
+        - Do we want to specify the columns increasingly or
+          decreasingly? That is, should this be
+          ``Tab(columns = [[1,3],[2,4]])``?
+        - Make this fully consistent with
+          :func:`~sage.combinat.tableau.Tableau`!
 
     We illustrate the use of a shape with a negative last entry in
     type `D`::
@@ -1031 +1518 @@
         # integer partitions of length the rank for type B and D. In
         # particular, for type D, the spins all have to be plus or all
         # minus spins
-        assert all(len(sh) == n for sh in shapes), \
-            "the length of all half-integer partition shapes should be the rank"
-        assert all(2*i % 2 == 1 for shape in spin_shapes for i in shape), \
-            "shapes should be either all partitions or all half-integer partitions"
+        if any(len(sh) != n for sh in shapes):
+            raise ValueError("the length of all half-integer partition shapes should be the rank")
+        if any(2*i % 2 != 1 for shape in spin_shapes for i in shape):
+            raise ValueError("shapes should be either all partitions or all half-integer partitions")
         if cartan_type.type() == 'D':
             if all( i >= 0 for shape in spin_shapes for i in shape):
                 S = CrystalOfSpinsPlus(cartan_type)
             elif all(shape[-1]<0 for shape in spin_shapes):
                 S = CrystalOfSpinsMinus(cartan_type)
             else:
-                raise ValueError, "In type D spins should all be positive or negative"
+                raise ValueError("In type D spins should all be positive or negative")
         else:
-            assert all( i >= 0 for shape in spin_shapes for i in shape), \
-                "shapes should all be partitions"
+            if any( i < 0 for shape in spin_shapes for i in shape):
+                raise ValueError("shapes should all be partitions")
             S = CrystalOfSpins(cartan_type)
         B = CrystalOfTableaux(cartan_type, shapes = shapes)
         T = TensorProductOfCrystals(S,B, generators=[[S.module_generators[0],x] for x in B.module_generators])
@@ -1058 +1545 @@
         Construct the crystal of all tableaux of the given shapes
 
         INPUT:
-         - ``cartan_type`` - (data coercible into) a cartan type
-         - ``shapes``      - a list (or iterable) of shapes
-         - ``shape` `      - a shape
+
+        - ``cartan_type`` - (data coercible into) a cartan type
+        - ``shapes``      - a list (or iterable) of shapes
+        - ``shape` `      - a shape
 
         shapes themselves are lists (or iterable) of integers
 
@@ -1141 +1629 @@
 
 
 
-class CrystalOfTableauxElement(TensorProductOfCrystalsElement):
+class CrystalOfTableauxElement(TensorProductOfRegularCrystalsElement):
+    """
+    Element in a crystal of tableaux.
+    """
     def __init__(self, parent, *args, **options):
         """
         There are several ways to input tableaux, by rows,
@@ -1217 +1708 @@
                 list+=col
         else:
             list = [i for i in args]
-        TensorProductOfCrystalsElement.__init__(self, parent, map(parent.letters, list))
+        TensorProductOfRegularCrystalsElement.__init__(self, parent, map(parent.letters, list))
 
     def _repr_(self):
         """

sage/combinat/rigged_configurations/kr_tableaux.py

@@ -49 +49 @@
 from sage.combinat.crystals.letters import CrystalOfLetters
 from sage.combinat.root_system.cartan_type import CartanType
 from sage.combinat.crystals.tensor_product import CrystalOfWords
-from sage.combinat.crystals.tensor_product import TensorProductOfCrystalsElement
+from sage.combinat.crystals.tensor_product import TensorProductOfRegularCrystalsElement
 from sage.combinat.crystals.kirillov_reshetikhin import horizontal_dominoes_removed, \
   KirillovReshetikhinCrystal, KirillovReshetikhinGenericCrystalElement
 from sage.combinat.partition import Partition
@@ -477 +477 @@
 #        shapes = [Partition(map(lambda x: Integer(x*2), shape)).conjugate() for shape in shapes]
 #        self.module_generators = tuple(self._fill(Partition(shape).conjugate()) for shape in shapes)
 
-class KirillovReshetikhinTableauxElement(TensorProductOfCrystalsElement):
+class KirillovReshetikhinTableauxElement(TensorProductOfRegularCrystalsElement):
     r"""
     A Kirillov-Reshetikhin tableau.
 
@@ -499 +499 @@
         # Make sure we are a list of letters
         if list != [] and type(list[0]) is not CrystalOfLetters:
             list = [parent.letters(x) for x in list]
-        TensorProductOfCrystalsElement.__init__(self, parent, list)
+        TensorProductOfRegularCrystalsElement.__init__(self, parent, list)
 
     def _repr_(self):
         """
@@ -690 +690 @@
             if ret is None:
                 return None
             return ret.to_Kirillov_Reshetikhin_tableau()
-        return TensorProductOfCrystalsElement.e(self, i)
+        return TensorProductOfRegularCrystalsElement.e(self, i)
 
     def f(self, i):
         """
@@ -711 +711 @@
             if ret is None:
                 return None
             return ret.to_Kirillov_Reshetikhin_tableau()
-        return TensorProductOfCrystalsElement.f(self, i)
+        return TensorProductOfRegularCrystalsElement.f(self, i)
 
 KirillovReshetikhinTableaux.Element = KirillovReshetikhinTableauxElement
 
@@ -733 +733 @@
             [[1], [3], [-4], [-2]]
             sage: KRT([-1, -4, 3, 2]).e(3)
         """
-        half = TensorProductOfCrystalsElement.e(self, i)
+        half = TensorProductOfRegularCrystalsElement.e(self, i)
         if half is None:
             return None
-        return TensorProductOfCrystalsElement.e(half, i)
+        return TensorProductOfRegularCrystalsElement.e(half, i)
 
     def f(self, i):
         r"""
@@ -749 +749 @@
             sage: KRT([-1, -4, 3, 2]).f(3)
             [[2], [4], [-3], [-1]]
         """
-        half = TensorProductOfCrystalsElement.f(self, i)
+        half = TensorProductOfRegularCrystalsElement.f(self, i)
         if half is None:
             return None
 
-        return TensorProductOfCrystalsElement.f(half, i)
+        return TensorProductOfRegularCrystalsElement.f(half, i)
 
     def epsilon(self, i):
         r"""
@@ -767 +767 @@
             sage: KRT([-1, -4, 3, 2]).epsilon(3)
             0
         """
-        return TensorProductOfCrystalsElement.epsilon(self, i) / 2
+        return TensorProductOfRegularCrystalsElement.epsilon(self, i) / 2
 
     def phi(self, i):
         r"""
@@ -781 +781 @@
             sage: KRT([-1, -4, 3, 2]).phi(3)
             1
         """
-        return TensorProductOfCrystalsElement.phi(self, i) / 2
+        return TensorProductOfRegularCrystalsElement.phi(self, i) / 2
 
     @cached_method
     def to_array(self, rows=True):

sage/combinat/rigged_configurations/rigged_configurations.py

@@ -436 +436 @@
                 raise ValueError("Incorrect bijection image.")
             return lst[0].to_rigged_configuration()
 
-        from sage.combinat.crystals.tensor_product import TensorProductOfCrystalsElement
-        if isinstance(lst[0], TensorProductOfCrystalsElement):
+        from sage.combinat.crystals.tensor_product import TensorProductOfRegularCrystalsElement
+        if isinstance(lst[0], TensorProductOfRegularCrystalsElement):
             lst = lst[0]
         from sage.combinat.crystals.kirillov_reshetikhin import KirillovReshetikhinGenericCrystalElement
         if isinstance(lst[0], KirillovReshetikhinGenericCrystalElement):

sage/combinat/rigged_configurations/tensor_product_kr_tableaux.py

@@ -67 +67 @@
 from sage.misc.cachefunc import cached_method
 from sage.misc.lazy_attribute import lazy_attribute
 
-from sage.combinat.crystals.tensor_product import FullTensorProductOfCrystals
+from sage.combinat.crystals.tensor_product import FullTensorProductOfRegularCrystals
 from sage.combinat.crystals.letters import CrystalOfLetters
 from sage.combinat.root_system.cartan_type import CartanType
 
@@ -76 +76 @@
 
 from sage.rings.integer import Integer
 
-class AbstractTensorProductOfKRTableaux(FullTensorProductOfCrystals):
+class AbstractTensorProductOfKRTableaux(FullTensorProductOfRegularCrystals):
     r"""
     Abstract class for all of tensor product of KR tableaux of a given Cartan type.
 
@@ -115 +115 @@
             tensorProd.append(KirillovReshetikhinTableaux(
               self.letters.cartan_type(),
               rectDims[0], rectDims[1]))
-        FullTensorProductOfCrystals.__init__(self, tuple(tensorProd))
+        FullTensorProductOfRegularCrystals.__init__(self, tuple(tensorProd))
         
     def _highest_weight_iter(self):
         r"""
@@ -159 +159 @@
         if isinstance(path[0], KirillovReshetikhinGenericCrystalElement):
             return self.element_class(self, *[x.to_Kirillov_Reshetikhin_tableau() for x in path])
 
-        from sage.combinat.crystals.tensor_product import TensorProductOfCrystalsElement
-        if isinstance(path[0], TensorProductOfCrystalsElement) and \
+        from sage.combinat.crystals.tensor_product import TensorProductOfRegularCrystalsElement
+        if isinstance(path[0], TensorProductOfRegularCrystalsElement) and \
           isinstance(path[0][0], KirillovReshetikhinGenericCrystalElement):
             return self.element_class(self, *[x.to_Kirillov_Reshetikhin_tableau() for x in path[0]])
 
@@ -564 +564 @@
             sage: T is KRT.tensor_product_of_Kirillov_Reshetikhin_crystals()
             True
         """
-        return FullTensorProductOfCrystals(tuple(x.Kirillov_Reshetikhin_crystal() for x in self.crystals),
+        return FullTensorProductOfRegularCrystals(tuple(x.Kirillov_Reshetikhin_crystal() for x in self.crystals),
                                            cartan_type=self.affine_ct)
 
 TensorProductOfKirillovReshetikhinTableaux.Element = TensorProductOfKirillovReshetikhinTableauxElement

sage/combinat/rigged_configurations/tensor_product_kr_tableaux_element.py

@@ -96 +96 @@
 #*****************************************************************************
 
 from sage.combinat.root_system.cartan_type import CartanType
-from sage.combinat.crystals.tensor_product import TensorProductOfCrystalsElement
+from sage.combinat.crystals.tensor_product import TensorProductOfRegularCrystalsElement
 from sage.combinat.rigged_configurations.bijection import KRTToRCBijection
 
-class TensorProductOfKirillovReshetikhinTableauxElement(TensorProductOfCrystalsElement):
+class TensorProductOfKirillovReshetikhinTableauxElement(TensorProductOfRegularCrystalsElement):
     """
     An element in a tensor product of Kirillov-Reshetikhin tableaux.
 
@@ -134 +134 @@
 
         if "pathlist" in options:
             pathlist = options["pathlist"]
-            TensorProductOfCrystalsElement.__init__(self, parent,
+            TensorProductOfRegularCrystalsElement.__init__(self, parent,
               [parent.crystals[i](list(tab)) for i, tab in enumerate(pathlist)])
         elif "list" in options:
-            TensorProductOfCrystalsElement.__init__(self, parent, **options)
+            TensorProductOfRegularCrystalsElement.__init__(self, parent, **options)
         else:
-            TensorProductOfCrystalsElement.__init__(self, parent, list(path))
+            TensorProductOfRegularCrystalsElement.__init__(self, parent, list(path))
 
     def _repr_(self):
         """
@@ -170 +170 @@
             [[2], [4]]
         """
         if i != 0:
-            return TensorProductOfCrystalsElement.e(self, i)
+            return TensorProductOfRegularCrystalsElement.e(self, i)
 
         return None
 
@@ -187 +187 @@
             [[-4], [4]]
         """
         if i != 0:
-            return TensorProductOfCrystalsElement.f(self, i)
+            return TensorProductOfRegularCrystalsElement.f(self, i)
 
         return None
 

sage/doctest/sources.py

@@ -674 +674 @@
             ....:             FDS._test_enough_doctests(verbose=False)
             There are 18 tests in sage/combinat/partition.py that are not being run
             There are 18 tests in sage/combinat/tableau.py that are not being run
+            There are 8 tests in sage/combinat/crystals/tensor_product.py that are not being run
             There are 15 tests in sage/combinat/root_system/cartan_type.py that are not being run
             There are 8 tests in sage/combinat/root_system/type_A.py that are not being run
             There are 8 tests in sage/combinat/root_system/type_G.py that are not being run