passagemath-combinat 10.6.42__cp314-cp314t-win_amd64.whl

sage/combinat/k_tableau.py

@@ -0,0 +1,4564 @@
+# sage_setup: distribution = sagemath-combinat
+# sage.doctest: needs sage.combinat sage.modules
+r"""
+Strong and weak tableaux
+
+There are two types of `k`-tableaux: strong `k`-tableaux and weak `k`-tableaux.
+Standard weak `k`-tableaux correspond to saturated chains in the weak order,
+whereas standard strong `k`-tableaux correspond to saturated chains in the strong Bruhat order.
+For semistandard tableaux, the notion of weak and strong horizontal strip is necessary.
+More information can be found in [LLMS2006]_ .
+
+.. SEEALSO:: :meth:`sage.combinat.k_tableau.StrongTableau`, :meth:`sage.combinat.k_tableau.WeakTableau`
+
+Authors:
+
+- Anne Schilling and Mike Zabrocki (2013): initial version
+- Avi Dalal and Nate Gallup (2013): implementation of `k`-charge
+"""
+#*****************************************************************************
+#       Copyright (C) 2013 Anne Schilling <anne at math.ucdavis.edu>
+#                          Mike Zabrocki  <zabrocki at mathstat.yorku.ca>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#
+#    This code is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#    General Public License for more details.
+#
+#  The full text of the GPL is available at:
+#
+#                  https://www.gnu.org/licenses/
+#****************************************************************************
+from itertools import repeat
+from sage.structure.unique_representation import UniqueRepresentation
+from sage.categories.finite_enumerated_sets import FiniteEnumeratedSets
+from sage.structure.parent import Parent
+from sage.structure.list_clone import ClonableList
+from sage.misc.inherit_comparison import InheritComparisonClasscallMetaclass
+from sage.combinat.skew_tableau import SkewTableau, SemistandardSkewTableaux
+from sage.combinat.partition import Partition, Partitions
+from sage.combinat.core import Core
+from sage.rings.integer_ring import ZZ
+from sage.functions.generalized import sgn
+from sage.misc.lazy_import import lazy_import
+from sage.misc.flatten import flatten
+from sage.combinat.skew_partition import SkewPartition
+from sage.combinat.tableau import Tableaux
+from sage.combinat.composition import Composition
+import copy
+
+lazy_import('sage.combinat.root_system.weyl_group', 'WeylGroup')
+
+
+def WeakTableau(t, k, inner_shape=[], representation='core'):
+    r"""
+    This is the dispatcher method for the element class of weak `k`-tableaux.
+
+    Standard weak `k`-tableaux correspond to saturated chains in the weak order.
+    There are three formulations of weak tableaux, one in terms of cores, one in terms
+    of `k`-bounded partitions, and one in terms of factorizations of affine Grassmannian
+    elements. For semistandard weak `k`-tableaux, all letters of the same value have to
+    satisfy the conditions of a horizontal strip. In the affine Grassmannian formulation this
+    means that all factors are cyclically decreasing elements. For more information, see
+    for example [LLMSSZ2013]_.
+
+    INPUT:
+
+    - ``t`` -- a weak `k`-tableau in the specified representation:
+
+      - for the 'core' representation ``t`` is a list of lists where each subtableaux
+        should have a `k+1`-core shape; ``None`` is allowed as an entry for skew weak
+        `k`-tableaux
+      - for the 'bounded' representation ``t`` is a list of lists where each subtableaux
+        should have a `k`-bounded shape; ``None`` is allowed as an entry for skew weak
+        `k`-tableaux
+      - for the 'factorized_permutation' representation ``t`` is either a list of
+        cyclically decreasing Weyl group elements or a list of reduced words of cyclically
+        decreasing Weyl group elements; to indicate a skew tableau in this representation,
+        ``inner_shape`` should be the inner shape as a `(k+1)`-core
+
+    - ``k`` -- positive integer
+
+    - ``inner_shape`` -- this entry is only relevant for the 'factorized_permutation'
+      representation and specifies the inner shape in case the tableau is skew
+      (default: ``[]``)
+
+    - ``representation`` -- 'core', 'bounded', or 'factorized_permutation'
+      (default: ``'core'``)
+
+    EXAMPLES:
+
+    Here is an example of a weak 3-tableau in core representation::
+
+        sage: t = WeakTableau([[1, 1, 2, 2, 3], [2, 3], [3]], 3)
+        sage: t.shape()
+        [5, 2, 1]
+        sage: t.weight()
+        (2, 2, 2)
+        sage: type(t)
+        <class 'sage.combinat.k_tableau.WeakTableaux_core_with_category.element_class'>
+
+    And now we give a skew weak 3-tableau in core representation::
+
+        sage: ts = WeakTableau([[None, 1, 1, 2, 2], [None, 2], [1]], 3)
+        sage: ts.shape()
+        ([5, 2, 1], [1, 1])
+        sage: ts.weight()
+        (2, 2)
+        sage: type(ts)
+        <class 'sage.combinat.k_tableau.WeakTableaux_core_with_category.element_class'>
+
+    Next we create the analogue of the first example in bounded representation::
+
+        sage: tb = WeakTableau([[1,1,2],[2,3],[3]], 3, representation='bounded')
+        sage: tb.shape()
+        [3, 2, 1]
+        sage: tb.weight()
+        (2, 2, 2)
+        sage: type(tb)
+        <class 'sage.combinat.k_tableau.WeakTableaux_bounded_with_category.element_class'>
+        sage: tb.to_core_tableau()
+        [[1, 1, 2, 2, 3], [2, 3], [3]]
+        sage: t == tb.to_core_tableau()
+        True
+
+    And the analogue of the skew example in bounded representation::
+
+        sage: tbs = WeakTableau([[None, 1, 2], [None, 2], [1]], 3, representation = "bounded")
+        sage: tbs.shape()
+        ([3, 2, 1], [1, 1])
+        sage: tbs.weight()
+        (2, 2)
+        sage: tbs.to_core_tableau()
+        [[None, 1, 1, 2, 2], [None, 2], [1]]
+        sage: ts.to_bounded_tableau() == tbs
+        True
+
+    Finally we do the same examples for the factorized permutation representation::
+
+        sage: tf = WeakTableau([[2,0],[3,2],[1,0]], 3, representation = "factorized_permutation")
+        sage: tf.shape()
+        [5, 2, 1]
+        sage: tf.weight()
+        (2, 2, 2)
+        sage: type(tf)
+        <class 'sage.combinat.k_tableau.WeakTableaux_factorized_permutation_with_category.element_class'>
+        sage: tf.to_core_tableau() == t
+        True
+
+        sage: tfs = WeakTableau([[0,3],[2,1]], 3, inner_shape = [1,1], representation = 'factorized_permutation')
+        sage: tfs.shape()
+        ([5, 2, 1], [1, 1])
+        sage: tfs.weight()
+        (2, 2)
+        sage: type(tfs)
+        <class 'sage.combinat.k_tableau.WeakTableaux_factorized_permutation_with_category.element_class'>
+        sage: tfs.to_core_tableau()
+        [[None, 1, 1, 2, 2], [None, 2], [1]]
+
+    Another way to pass from one representation to another is as follows::
+
+        sage: ts
+        [[None, 1, 1, 2, 2], [None, 2], [1]]
+        sage: ts.parent()._representation
+        'core'
+        sage: ts.representation('bounded')
+        [[None, 1, 2], [None, 2], [1]]
+
+    To test whether a given semistandard tableau is a weak `k`-tableau in the bounded representation,
+    one can ask::
+
+        sage: t = Tableau([[1,1,2],[2,3],[3]])
+        sage: t.is_k_tableau(3)
+        True
+        sage: t = SkewTableau([[None, 1, 2], [None, 2], [1]])
+        sage: t.is_k_tableau(3)
+        True
+        sage: t = SkewTableau([[None, 1, 1], [None, 2], [2]])
+        sage: t.is_k_tableau(3)
+        False
+
+    TESTS::
+
+        sage: t = WeakTableau([[2,0],[3,2],[1,0]], 3, representation = "bla")
+        Traceback (most recent call last):
+        ...
+        NotImplementedError: The representation option needs to be 'core', 'bounded', or 'factorized_permutation'
+    """
+    if representation == "core":
+        return WeakTableau_core(t, k)
+    elif representation == "bounded":
+        return WeakTableau_bounded(t, k)
+    elif representation == "factorized_permutation":
+        return WeakTableau_factorized_permutation(t, k, inner_shape=inner_shape)
+    else:
+        raise NotImplementedError("The representation option needs to be 'core', 'bounded', or 'factorized_permutation'")
+
+
+def WeakTableaux(k, shape , weight, representation='core'):
+    r"""
+    This is the dispatcher method for the parent class of weak `k`-tableaux.
+
+    INPUT:
+
+    - ``k`` -- positive integer
+    - ``shape`` -- shape of the weak `k`-tableaux; for the 'core' and
+      'factorized_permutation' representation, the shape is inputted as a `(k+1)`-core;
+      for the 'bounded' representation, the shape is inputted as a `k`-bounded partition;
+      for skew tableaux, the shape is inputted as a tuple of the outer and inner shape
+    - ``weight`` -- the weight of the weak `k`-tableaux as a list or tuple
+    - ``representation`` -- ``'core'``, ``'bounded'``, or ``'factorized_permutation'`` (default: ``'core'``)
+
+    EXAMPLES::
+
+        sage: T = WeakTableaux(3, [5,2,1], [1,1,1,1,1,1])
+        sage: T.list()
+        [[[1, 3, 4, 5, 6], [2, 6], [4]],
+        [[1, 2, 4, 5, 6], [3, 6], [4]],
+        [[1, 2, 3, 4, 6], [4, 6], [5]],
+        [[1, 2, 3, 4, 5], [4, 5], [6]]]
+        sage: T.cardinality()
+        4
+
+        sage: T = WeakTableaux(3, [[5,2,1], [2]], [1,1,1,1])
+        sage: T.list()
+        [[[None, None, 2, 3, 4], [1, 4], [2]],
+        [[None, None, 1, 2, 4], [2, 4], [3]],
+        [[None, None, 1, 2, 3], [2, 3], [4]]]
+
+        sage: T = WeakTableaux(3, [3,2,1], [1,1,1,1,1,1], representation = 'bounded')
+        sage: T.list()
+        [[[1, 3, 5], [2, 6], [4]],
+        [[1, 2, 5], [3, 6], [4]],
+        [[1, 2, 3], [4, 6], [5]],
+        [[1, 2, 3], [4, 5], [6]]]
+
+        sage: T = WeakTableaux(3, [[3,2,1], [2]], [1,1,1,1], representation = 'bounded')
+        sage: T.list()
+        [[[None, None, 3], [1, 4], [2]],
+        [[None, None, 1], [2, 4], [3]],
+        [[None, None, 1], [2, 3], [4]]]
+
+        sage: T = WeakTableaux(3, [5,2,1], [1,1,1,1,1,1], representation = 'factorized_permutation')
+        sage: T.list()
+        [[s0, s3, s2, s1, s3, s0],
+        [s0, s3, s2, s3, s1, s0],
+        [s0, s2, s3, s2, s1, s0],
+        [s2, s0, s3, s2, s1, s0]]
+
+        sage: T = WeakTableaux(3, [[5,2,1], [2]], [1,1,1,1], representation = 'factorized_permutation')
+        sage: T.list()
+        [[s0, s3, s2, s3], [s0, s2, s3, s2], [s2, s0, s3, s2]]
+    """
+    if representation == "core":
+        return WeakTableaux_core(k, shape, weight)
+    elif representation == "bounded":
+        return WeakTableaux_bounded(k, shape, weight)
+    elif representation == "factorized_permutation":
+        return WeakTableaux_factorized_permutation(k, shape, weight)
+    else:
+        raise NotImplementedError("The representation option needs to be 'core', 'bounded', or 'factorized_permutation'")
+
+#Abstract class for the elements of weak tableau
+
+
+class WeakTableau_abstract(ClonableList,
+        metaclass=InheritComparisonClasscallMetaclass):
+    r"""
+    Abstract class for the various element classes of WeakTableau.
+    """
+
+    def shape(self):
+        r"""
+        Return the shape of ``self``.
+
+        When the tableau is straight, the outer shape is returned.
+        When the tableau is skew, the tuple of the outer and inner shape is returned.
+
+        EXAMPLES::
+
+            sage: t = WeakTableau([[1, 1, 2, 2, 3], [2, 3], [3]], 3)
+            sage: t.shape()
+            [5, 2, 1]
+            sage: t = WeakTableau([[None, None, 2, 3, 4], [1, 4], [2]], 3)
+            sage: t.shape()
+            ([5, 2, 1], [2])
+
+            sage: t = WeakTableau([[1,1,1],[2,2],[3]], 3, representation = 'bounded')
+            sage: t.shape()
+            [3, 2, 1]
+            sage: t = WeakTableau([[None, None, 1], [2, 4], [3]], 3, representation = 'bounded')
+            sage: t.shape()
+            ([3, 2, 1], [2])
+
+            sage: t = WeakTableau([[2],[0,3],[2,1,0]], 3, representation = 'factorized_permutation')
+            sage: t.shape()
+            [5, 2, 1]
+            sage: t = WeakTableau([[2,0],[3,2]], 3, inner_shape = [2], representation = 'factorized_permutation')
+            sage: t.shape()
+            ([5, 2, 1], [2])
+        """
+        return self.parent().shape()
+
+    def weight(self):
+        r"""
+        Return the weight of ``self``.
+
+        The weight is a tuple whose `i`-th entry is the number of labels `i` in the
+        bounded representation of ``self``.
+
+        EXAMPLES::
+
+            sage: t = WeakTableau([[1, 1, 2, 2, 3], [2, 3], [3]], 3)
+            sage: t.weight()
+            (2, 2, 2)
+            sage: t = WeakTableau([[None, None, 2, 3, 4], [1, 4], [2]], 3)
+            sage: t.weight()
+            (1, 1, 1, 1)
+            sage: t = WeakTableau([[None,2,3],[3]],2)
+            sage: t.weight()
+            (0, 1, 1)
+
+            sage: t = WeakTableau([[1,1,1],[2,2],[3]], 3, representation = 'bounded')
+            sage: t.weight()
+            (3, 2, 1)
+            sage: t = WeakTableau([[1,1,2],[2,3],[3]], 3, representation = 'bounded')
+            sage: t.weight()
+            (2, 2, 2)
+            sage: t = WeakTableau([[None, None, 1], [2, 4], [3]], 3, representation = 'bounded')
+            sage: t.weight()
+            (1, 1, 1, 1)
+
+            sage: t = WeakTableau([[2],[0,3],[2,1,0]], 3, representation = 'factorized_permutation')
+            sage: t.weight()
+            (3, 2, 1)
+            sage: t = WeakTableau([[2,0],[3,2],[1,0]], 3, representation = 'factorized_permutation')
+            sage: t.weight()
+            (2, 2, 2)
+            sage: t = WeakTableau([[2,0],[3,2]], 3, inner_shape = [2], representation = 'factorized_permutation')
+            sage: t.weight()
+            (2, 2)
+        """
+        return self.parent()._weight
+
+    def size(self):
+        r"""
+        Return the size of the shape of ``self``.
+
+        In the bounded representation, the size of the shape is the number of boxes in the
+        outer shape minus the number of boxes in the inner shape. For the core and
+        factorized permutation representation, the size is the length of the outer shape
+        minus the length of the inner shape.
+
+        .. SEEALSO:: :meth:`sage.combinat.core.Core.length`
+
+        EXAMPLES::
+
+            sage: t = WeakTableau([[None, 1, 1, 2, 2], [None, 2], [1]], 3)
+            sage: t.shape()
+            ([5, 2, 1], [1, 1])
+            sage: t.size()
+            4
+            sage: t = WeakTableau([[1,1,2],[2,3],[3]], 3, representation='bounded')
+            sage: t.shape()
+            [3, 2, 1]
+            sage: t.size()
+            6
+        """
+        return self.parent().size()
+
+    def intermediate_shapes(self):
+        r"""
+        Return the intermediate shapes of ``self``.
+
+        A (skew) tableau with letters `1,2,\ldots,\ell` can be viewed as a sequence of shapes,
+        where the `i`-th shape is given by the shape of the subtableau on letters `1,2,\ldots,i`.
+        The output is the list of these shapes.
+
+        EXAMPLES::
+
+            sage: t = WeakTableau([[1, 1, 2, 2, 3], [2, 3], [3]],3)
+            sage: t.intermediate_shapes()
+            [[], [2], [4, 1], [5, 2, 1]]
+
+            sage: t = WeakTableau([[None, None, 2, 3, 4], [1, 4], [2]], 3)
+            sage: t.intermediate_shapes()
+            [[2], [2, 1], [3, 1, 1], [4, 1, 1], [5, 2, 1]]
+
+            sage: t = WeakTableau([[1,1,1],[2,2],[3]], 3, representation = 'bounded')
+            sage: t.intermediate_shapes()
+            [[], [3], [3, 2], [3, 2, 1]]
+
+            sage: t = WeakTableau([[None, None, 1], [2, 4], [3]], 3, representation = 'bounded')
+            sage: t.intermediate_shapes()
+            [[2], [3], [3, 1], [3, 1, 1], [3, 2, 1]]
+
+            sage: t = WeakTableau([[0],[3],[2],[3]], 3, inner_shape = [2], representation = 'factorized_permutation')
+            sage: t.intermediate_shapes()
+            [[2], [2, 1], [3, 1, 1], [4, 1, 1], [5, 2, 1]]
+        """
+        if self.parent()._representation in ['core', 'bounded']:
+            return intermediate_shapes(self)
+        else:
+            return intermediate_shapes(self.to_core_tableau())
+
+    def pp(self):
+        r"""
+        Return a pretty print string of the tableau.
+
+        EXAMPLES::
+
+            sage: t = WeakTableau([[None, 1, 1, 2, 2], [None, 2], [1]], 3)
+            sage: t.pp()
+            .  1  1  2  2
+            .  2
+            1
+            sage: t = WeakTableau([[2,0],[3,2]], 3, inner_shape = [2], representation = 'factorized_permutation')
+            sage: t.pp()
+            [s2*s0, s3*s2]
+        """
+        if self.parent()._representation in ['core', 'bounded']:
+            print(self._repr_diagram())
+        else:
+            print(self)
+
+    def __hash__(self):
+        r"""
+        Return the hash of ``self``.
+
+        EXAMPLES::
+
+            sage: T = WeakTableaux(3, [5,2,1], [1,1,1,1,1,1], representation='core')
+            sage: t = T[0]
+            sage: hash(t) == hash(t)
+            True
+            sage: T = WeakTableaux(3, [2,2,1], [1,1,1,1,1], representation='bounded')
+            sage: t = T[0]
+            sage: hash(t) == hash(t)
+            True
+            sage: T = WeakTableaux(3, [5,2,1], [1,1,1,1,1,1], representation='factorized_permutation')
+            sage: t = T[0]
+            sage: hash(t) == hash(t)
+            True
+        """
+        if self.parent()._representation in ['core', 'bounded']:
+            return hash(tuple(tuple(x) for x in self)) + hash(self.parent().k)
+        else:
+            return super().__hash__()
+
+    def _latex_(self):
+        r"""
+        Return a latex method for the tableau.
+
+        EXAMPLES::
+
+            sage: t = WeakTableau([[None, 1, 1, 2, 2], [None, 2], [1]], 3)
+            sage: latex(t)
+            {\def\lr#1{\multicolumn{1}{|@{\hspace{.6ex}}c@{\hspace{.6ex}}|}{\raisebox{-.3ex}{$#1$}}}
+            \raisebox{-.6ex}{$\begin{array}[b]{*{5}c}\cline{1-5}
+            \lr{}&\lr{1}&\lr{1}&\lr{2}&\lr{2}\\\cline{1-5}
+            \lr{}&\lr{2}\\\cline{1-2}
+            \lr{1}\\\cline{1-1}
+            \end{array}$}
+            }
+
+            sage: t = WeakTableau([[0,3],[2,1]], 3, inner_shape = [1,1], representation = 'factorized_permutation')
+            sage: latex(t)
+            [s_{0}s_{3},s_{2}s_{1}]
+        """
+        def chi(x):
+            if x is None:
+                return ""
+            if x in ZZ:
+                return x
+            return "%s" % x
+        if self.parent()._representation in ['core', 'bounded']:
+            t = [[chi(x) for x in row] for row in self]
+            from .output import tex_from_array
+            return tex_from_array(t)
+        else:
+            return "["+"".join(self[i]._latex_()+',' for i in range(len(self)-1))+self[len(self)-1]._latex_()+"]"
+
+    def representation(self, representation='core'):
+        r"""
+        Return the analogue of ``self`` in the specified representation.
+
+        INPUT:
+
+        - ``representation`` -- 'core', 'bounded', or 'factorized_permutation' (default: ``'core'``)
+
+        EXAMPLES::
+
+            sage: t = WeakTableau([[1, 1, 2, 3, 4, 4, 5, 5, 6], [2, 3, 5, 5, 6], [3, 4, 7], [5, 6], [6], [7]], 4)
+            sage: t.parent()._representation
+            'core'
+            sage: t.representation('bounded')
+            [[1, 1, 2, 4], [2, 3, 5], [3, 4], [5, 6], [6], [7]]
+            sage: t.representation('factorized_permutation')
+            [s0, s3*s1, s2*s1, s0*s4, s3*s0, s4*s2, s1*s0]
+
+            sage: tb = WeakTableau([[1, 1, 2, 4], [2, 3, 5], [3, 4], [5, 6], [6], [7]], 4, representation = 'bounded')
+            sage: tb.parent()._representation
+            'bounded'
+            sage: tb.representation('core') == t
+            True
+            sage: tb.representation('factorized_permutation')
+            [s0, s3*s1, s2*s1, s0*s4, s3*s0, s4*s2, s1*s0]
+
+            sage: tp = WeakTableau([[0],[3,1],[2,1],[0,4],[3,0],[4,2],[1,0]], 4, representation = 'factorized_permutation')
+            sage: tp.parent()._representation
+            'factorized_permutation'
+            sage: tp.representation('core') == t
+            True
+            sage: tp.representation('bounded') == tb
+            True
+        """
+        t = self
+        if self.parent()._representation in ['bounded', 'factorized_permutation']:
+            t = t.to_core_tableau()
+        if representation == 'core':
+            return t
+        elif representation == 'bounded':
+            return t.to_bounded_tableau()
+        elif representation == 'factorized_permutation':
+            return t.to_factorized_permutation_tableau()
+        else:
+            raise ValueError("The representation must be one of 'core', 'bounded', or 'factorized_permutation'")
+
+#Abstract class for the parents of weak tableaux
+
+
+class WeakTableaux_abstract(UniqueRepresentation, Parent):
+    r"""
+    Abstract class for the various parent classes of WeakTableaux.
+    """
+
+    def shape(self):
+        r"""
+        Return the shape of the tableaux of ``self``.
+
+        When ``self`` is the class of straight tableaux, the outer shape is returned.
+        When ``self`` is the class of skew tableaux, the tuple of the outer and inner
+        shape is returned.
+
+        Note that in the 'core' and 'factorized_permutation' representation, the shapes
+        are `(k+1)`-cores.  In the 'bounded' representation, the shapes are `k`-bounded
+        partitions.
+
+        If the user wants to access the skew shape (even if the inner shape is empty),
+        please use ``self._shape``.
+
+        EXAMPLES::
+
+            sage: T = WeakTableaux(3, [5,2,2], [2,2,2,1])
+            sage: T.shape()
+            [5, 2, 2]
+            sage: T._shape
+            ([5, 2, 2], [])
+            sage: T = WeakTableaux(3, [[5,2,2], [1]], [2,1,2,1])
+            sage: T.shape()
+            ([5, 2, 2], [1])
+
+            sage: T = WeakTableaux(3, [3,2,2], [2,2,2,1], representation = 'bounded')
+            sage: T.shape()
+            [3, 2, 2]
+            sage: T._shape
+            ([3, 2, 2], [])
+            sage: T = WeakTableaux(3, [[3,2,2], [1]], [2,1,2,1], representation = 'bounded')
+            sage: T.shape()
+            ([3, 2, 2], [1])
+
+            sage: T = WeakTableaux(3, [4,1], [2,2], representation = 'factorized_permutation')
+            sage: T.shape()
+            [4, 1]
+            sage: T._shape
+            ([4, 1], [])
+            sage: T = WeakTableaux(4, [[6,2,1], [2]], [2,1,1,1], representation = 'factorized_permutation')
+            sage: T.shape()
+            ([6, 2, 1], [2])
+        """
+        if self._skew:
+            return (self._outer_shape, self._inner_shape)
+        return self._outer_shape
+
+    def size(self):
+        r"""
+        Return the size of the shape.
+
+        In the bounded representation, the size of the shape is the number of boxes in the
+        outer shape minus the number of boxes in the inner shape. For the core and
+        factorized permutation representation, the size is the length of the outer shape
+        minus the length of the inner shape.
+
+        EXAMPLES::
+
+            sage: T = WeakTableaux(3, [5,2,1], [1,1,1,1,1,1])
+            sage: T.size()
+            6
+            sage: T = WeakTableaux(3, [3,2,1], [1,1,1,1,1,1], representation = 'bounded')
+            sage: T.size()
+            6
+            sage: T = WeakTableaux(4, [[6,2,1], [2]], [2,1,1,1], 'factorized_permutation')
+            sage: T.size()
+            5
+        """
+        if self._representation == 'bounded':
+            return self._outer_shape.size() - self._inner_shape.size()
+        else:
+            return self._outer_shape.length() - self._inner_shape.length()
+
+    def representation(self, representation='core'):
+        r"""
+        Return the analogue of ``self`` in the specified representation.
+
+        INPUT:
+
+        - ``representation`` -- 'core', 'bounded', or 'factorized_permutation' (default: ``'core'``)
+
+        EXAMPLES::
+
+            sage: T = WeakTableaux(3, [5,2,1], [1,1,1,1,1,1])
+            sage: T._representation
+            'core'
+            sage: T.representation('bounded')
+            Bounded weak 3-Tableaux of (skew) 3-bounded shape [3, 2, 1] and weight (1, 1, 1, 1, 1, 1)
+            sage: T.representation('factorized_permutation')
+            Factorized permutation (skew) weak 3-Tableaux of shape [5, 2, 1] and weight (1, 1, 1, 1, 1, 1)
+
+            sage: T = WeakTableaux(3, [3,2,1], [1,1,1,1,1,1], representation = 'bounded')
+            sage: T._representation
+            'bounded'
+            sage: T.representation('core')
+            Core weak 3-Tableaux of (skew) core shape [5, 2, 1] and weight (1, 1, 1, 1, 1, 1)
+            sage: T.representation('bounded')
+            Bounded weak 3-Tableaux of (skew) 3-bounded shape [3, 2, 1] and weight (1, 1, 1, 1, 1, 1)
+            sage: T.representation('bounded') == T
+            True
+            sage: T.representation('factorized_permutation')
+            Factorized permutation (skew) weak 3-Tableaux of shape [5, 2, 1] and weight (1, 1, 1, 1, 1, 1)
+            sage: T.representation('factorized_permutation') == T
+            False
+
+            sage: T = WeakTableaux(3, [5,2,1], [1,1,1,1,1,1], representation = 'factorized_permutation')
+            sage: T._representation
+            'factorized_permutation'
+            sage: T.representation('core')
+            Core weak 3-Tableaux of (skew) core shape [5, 2, 1] and weight (1, 1, 1, 1, 1, 1)
+            sage: T.representation('bounded')
+            Bounded weak 3-Tableaux of (skew) 3-bounded shape [3, 2, 1] and weight (1, 1, 1, 1, 1, 1)
+            sage: T.representation('factorized_permutation')
+            Factorized permutation (skew) weak 3-Tableaux of shape [5, 2, 1] and weight (1, 1, 1, 1, 1, 1)
+        """
+        outer_shape = self._outer_shape
+        inner_shape = self._inner_shape
+        weight = self._weight
+        if (self._representation in ['core', 'factorized_permutation']) and representation == 'bounded':
+            outer_shape = outer_shape.to_bounded_partition()
+            inner_shape = inner_shape.to_bounded_partition()
+        if self._representation == 'bounded' and (representation in ['core', 'factorized_permutation']):
+            outer_shape = outer_shape.to_core(self.k)
+            inner_shape = inner_shape.to_core(self.k)
+        return WeakTableaux(self.k, [outer_shape, inner_shape], weight, representation=representation)
+
+
+#Weak Tableaux in terms of cores
+class WeakTableau_core(WeakTableau_abstract):
+    r"""
+    A (skew) weak `k`-tableau represented in terms of `(k+1)`-cores.
+    """
+    @staticmethod
+    def __classcall_private__(cls, t, k):
+        r"""
+        Implement the shortcut ``WeakTableau_core(t, k)`` to
+        ``WeakTableaux_core(k, shape , weight)(t)`` where ``shape`` is the
+        shape of the tableau and ``weight`` is its weight.
+
+        TESTS::
+
+            sage: from sage.combinat.k_tableau import WeakTableau_core
+            sage: t = WeakTableau_core([[1, 1, 2, 2, 3], [2, 3], [3]], 3)
+            sage: t.check()
+            sage: type(t)
+            <class 'sage.combinat.k_tableau.WeakTableaux_core_with_category.element_class'>
+            sage: TestSuite(t).run()
+            sage: t.parent()._skew
+            False
+
+            sage: t = WeakTableau_core([[None, None, 1, 1, 2], [1, 2], [2]],3)
+            sage: t.check()
+            sage: type(t)
+            <class 'sage.combinat.k_tableau.WeakTableaux_core_with_category.element_class'>
+            sage: TestSuite(t).run()
+            sage: t.parent()._skew
+            True
+        """
+        if isinstance(t, cls):
+            return t
+        tab = SkewTableau(list(t))
+        outer = Core(tab.outer_shape(),k+1)
+        inner = Core(tab.inner_shape(),k+1)
+        weight = WeakTableau_bounded.from_core_tableau(t,k).weight()
+        return WeakTableaux_core(k, [outer, inner], weight)(t)
+
+    def __init__(self, parent, t):
+        r"""
+        Initialization of weak `k`-tableau ``t`` in core representation.
+
+        INPUT:
+
+        - ``t`` -- weak tableau in core representation; the input is supposed to be a list
+          of lists specifying the rows of the tableau;
+          ``None`` is allowed as an entry for skew weak `k`-tableaux
+
+        TESTS::
+
+            sage: from sage.combinat.k_tableau import WeakTableau_core, WeakTableaux_core
+            sage: T = WeakTableaux_core(3,[5,2,1],[2,2,2])
+            sage: t = T([[1, 1, 2, 2, 3], [2, 3], [3]]); t
+            [[1, 1, 2, 2, 3], [2, 3], [3]]
+            sage: c = WeakTableau_core([[1, 1, 2, 2, 3], [2, 3], [3]],3)
+            sage: T = WeakTableaux_core(3,[5,2,1],[2,2,2])
+            sage: t = T([[1, 1, 2, 2, 3], [2, 3], [3]]); t
+            [[1, 1, 2, 2, 3], [2, 3], [3]]
+            sage: c == t
+            True
+            sage: type(t)
+            <class 'sage.combinat.k_tableau.WeakTableaux_core_with_category.element_class'>
+            sage: t.parent()
+            Core weak 3-Tableaux of (skew) core shape [5, 2, 1] and weight (2, 2, 2)
+            sage: TestSuite(t).run()
+
+            sage: t = WeakTableau_core([[None, None, 1, 1, 2], [1, 2], [2]],3);  t
+            [[None, None, 1, 1, 2], [1, 2], [2]]
+            sage: t.weight()
+            (2, 2)
+            sage: t.shape()
+            ([5, 2, 1], [2])
+            sage: TestSuite(t).run()
+        """
+        self.k = parent.k
+        ClonableList.__init__(self, parent, t)
+
+    def _repr_diagram(self):
+        r"""
+        Return a string representation of ``self`` as a diagram.
+
+        EXAMPLES::
+
+            sage: t = WeakTableau([[None, None, 2, 3, 4], [1, 4], [2]], 3)
+            sage: print(t._repr_diagram())
+            .  .  2  3  4
+            1  4
+            2
+        """
+        t = SkewTableau(list(self))
+        return t._repr_diagram()
+
+    def shape_core(self):
+        r"""
+        Return the shape of ``self`` as a `(k+1)`-core.
+
+        When the tableau is straight, the outer shape is returned as a core.  When the
+        tableau is skew, the tuple of the outer and inner shape is returned as cores.
+
+        EXAMPLES::
+
+            sage: t = WeakTableau([[1, 1, 2, 2, 3], [2, 3], [3]],3)
+            sage: t.shape_core()
+            [5, 2, 1]
+
+            sage: t = WeakTableau([[None, None, 2, 3, 4], [1, 4], [2]], 3)
+            sage: t.shape_core()
+            ([5, 2, 1], [2])
+        """
+        return self.shape()
+
+    def shape_bounded(self):
+        r"""
+        Return the shape of ``self`` as a `k`-bounded partition.
+
+        When the tableau is straight, the outer shape is returned as a `k`-bounded
+        partition.  When the tableau is skew, the tuple of the outer and inner shape is
+        returned as `k`-bounded partitions.
+
+        EXAMPLES::
+
+            sage: t = WeakTableau([[1, 1, 2, 2, 3], [2, 3], [3]],3)
+            sage: t.shape_bounded()
+            [3, 2, 1]
+
+            sage: t = WeakTableau([[None, None, 2, 3, 4], [1, 4], [2]], 3)
+            sage: t.shape_bounded()
+            ([3, 2, 1], [2])
+        """
+        if self.parent()._skew:
+            return tuple([r.to_bounded_partition() for r in self.shape_core()])
+        return self.shape_core().to_bounded_partition()
+
+    def check(self):
+        r"""
+        Check that ``self`` is a valid weak `k`-tableau.
+
+        EXAMPLES::
+
+            sage: t = WeakTableau([[1, 1, 2], [2]], 2)
+            sage: t.check()
+            sage: t = WeakTableau([[None, None, 2, 3, 4], [1, 4], [2]], 3)
+            sage: t.check()
+
+        TESTS::
+
+            sage: T = WeakTableaux(2, [3,1], [1,1,1,1])
+            sage: t = T([[1,2,3],[3]])
+            Traceback (most recent call last):
+            ...
+            ValueError: The weight of the parent does not agree with the weight of the tableau!
+
+            sage: t = WeakTableau([[1, 2, 2], [1]], 2)
+            Traceback (most recent call last):
+            ...
+            ValueError: The tableau is not semistandard!
+        """
+        if not self.parent()._weight == WeakTableau_bounded.from_core_tableau(self,self.k).weight():
+            raise ValueError("The weight of the parent does not agree with the weight of the tableau!")
+        t = SkewTableau(list(self))
+        if t not in SemistandardSkewTableaux():
+            raise ValueError("The tableau is not semistandard!")
+        outer = Core(t.outer_shape(),self.k+1)
+        inner = Core(t.inner_shape(),self.k+1)
+        if self.parent()._outer_shape != outer:
+            raise ValueError("The outer shape of the parent does not agree with the outer shape of the tableau!")
+        if self.parent()._inner_shape != inner:
+            raise ValueError("The inner shape of the parent does not agree with the inner shape of the tableau!")
+        self.to_bounded_tableau().check()
+
+    def to_bounded_tableau(self):
+        r"""
+        Return the bounded representation of the weak `k`-tableau ``self``.
+
+        Each restricted subtableau of the output is a `k`-bounded partition.
+
+        EXAMPLES::
+
+            sage: t = WeakTableau([[1, 1, 2, 2, 3], [2, 3], [3]], 3)
+            sage: c = t.to_bounded_tableau(); c
+            [[1, 1, 2], [2, 3], [3]]
+            sage: type(c)
+            <class 'sage.combinat.k_tableau.WeakTableaux_bounded_with_category.element_class'>
+
+            sage: t = WeakTableau([[None, None, 2, 3, 4], [1, 4], [2]], 3)
+            sage: t.to_bounded_tableau()
+            [[None, None, 3], [1, 4], [2]]
+            sage: t.to_bounded_tableau().to_core_tableau() == t
+            True
+        """
+        shapes = [ Core(p,self.k+1).to_bounded_partition() for p in self.intermediate_shapes() ]
+        if self.parent()._skew:
+            l = [[None]*i for i in shapes[0]]
+        else:
+            l = []
+        for i in range(1,len(shapes)):
+            p = shapes[i]
+            if len(l) < len(p):
+                l += [[]]
+            l_new = []
+            for j in range(len(l)):
+                l_new += [l[j] + [i]*(p[j]-len(l[j]))]
+            l = l_new
+        return WeakTableau_bounded(l, self.k)
+
+    def to_factorized_permutation_tableau(self):
+        r"""
+        Return the factorized permutation representation of the weak `k`-tableau ``self``.
+
+        EXAMPLES::
+
+            sage: t = WeakTableau([[1, 1, 2, 2, 3], [2, 3], [3]], 3)
+            sage: c = t.to_factorized_permutation_tableau(); c
+            [s2*s0, s3*s2, s1*s0]
+            sage: type(c)
+            <class 'sage.combinat.k_tableau.WeakTableaux_factorized_permutation_with_category.element_class'>
+            sage: c.to_core_tableau() == t
+            True
+
+            sage: t = WeakTableau([[None, None, 2, 3, 4], [1, 4], [2]], 3)
+            sage: c = t.to_factorized_permutation_tableau(); c
+            [s0, s3, s2, s3]
+            sage: c._inner_shape
+            [2]
+            sage: c.to_core_tableau() == t
+            True
+
+        TESTS::
+
+            sage: t = WeakTableau([], 4)
+            sage: c = t.to_factorized_permutation_tableau(); c
+            [1]
+            sage: c._inner_shape
+            []
+            sage: c.to_core_tableau() == t
+            True
+        """
+        shapes = [ Core(p,self.k+1).to_grassmannian() for p in self.intermediate_shapes() ]
+        perms = [ shapes[i]*(shapes[i-1].inverse()) for i in range(len(shapes)-1,0,-1)]
+        return WeakTableau_factorized_permutation(perms, self.k, inner_shape=self.parent()._inner_shape)
+
+    def residues_of_entries(self, v):
+        r"""
+        Return a list of residues of cells of weak `k`-tableau ``self`` labeled by ``v``.
+
+        INPUT:
+
+        - ``v`` -- a label of a cell in ``self``
+
+        OUTPUT: list of residues
+
+        EXAMPLES::
+
+            sage: t = WeakTableau([[1, 1, 2, 2, 3], [2, 3], [3]],3)
+            sage: t.residues_of_entries(1)
+            [0, 1]
+
+            sage: t = WeakTableau([[None, None, 1, 1, 4], [1, 4], [3]], 3)
+            sage: t.residues_of_entries(1)
+            [2, 3]
+        """
+        S = set((j - i) % (self.k+1)
+                for i in range(len(self))
+                for j in range(len(self[i]))
+                if self[i][j] == v)
+        return sorted(S)
+
+    def dictionary_of_coordinates_at_residues(self, v):
+        r"""
+        Return a dictionary assigning to all residues of ``self`` with label ``v`` a list
+        of cells with the given residue.
+
+        INPUT:
+
+        - ``v`` -- a label of a cell in ``self``
+
+        OUTPUT: dictionary assigning coordinates in ``self`` to residues
+
+        EXAMPLES::
+
+            sage: t = WeakTableau([[1, 1, 2, 2, 3], [2, 3], [3]],3)
+            sage: t.dictionary_of_coordinates_at_residues(3)
+            {0: [(0, 4), (1, 1)], 2: [(2, 0)]}
+
+            sage: t = WeakTableau([[None, None, 1, 1, 4], [1, 4], [3]], 3)
+            sage: t.dictionary_of_coordinates_at_residues(1)
+            {2: [(0, 2)], 3: [(0, 3), (1, 0)]}
+
+            sage: t = WeakTableau([], 3)
+            sage: t.dictionary_of_coordinates_at_residues(1)
+            {}
+        """
+        d = {}
+        for r in self.residues_of_entries(v):
+            d[r] = []
+            for i in range(len(self)):
+                for j in range(len(self[i])):
+                    if self[i][j] == v and (j - i) % (self.k+1) == r:
+                        d[r] += [(i,j)]
+        return d
+
+    def list_of_standard_cells(self):
+        r"""
+        Return a list of lists of the coordinates of the standard cells of ``self``.
+
+        INPUT:
+
+        - ``self`` -- a weak `k`-tableau in core representation with partition weight
+
+        OUTPUT: list of lists of coordinates
+
+        .. WARNING::
+
+            This method currently only works for straight weak tableaux with partition
+            weight.
+
+        EXAMPLES::
+
+            sage: t = WeakTableau([[1, 1, 2, 2, 3], [2, 3], [3]], 3)
+            sage: t.list_of_standard_cells()
+            [[(0, 1), (1, 0), (2, 0)], [(0, 0), (0, 2), (1, 1)]]
+            sage: t = WeakTableau([[1, 1, 1, 2], [2, 2, 3]], 5)
+            sage: t.list_of_standard_cells()
+            [[(0, 2), (1, 1), (1, 2)], [(0, 1), (1, 0)], [(0, 0), (0, 3)]]
+            sage: t = WeakTableau([[1, 1, 2, 3, 4, 4, 5, 5, 6], [2, 3, 5, 5, 6], [3, 4, 7], [5, 6], [6], [7]], 4)
+            sage: t.list_of_standard_cells()
+            [[(0, 1), (1, 0), (2, 0), (0, 5), (3, 0), (4, 0), (5, 0)], [(0, 0), (0, 2), (1, 1), (2, 1), (1, 2), (3, 1)]]
+
+        TESTS::
+
+            sage: t = WeakTableau([],3)
+            sage: t.list_of_standard_cells()
+            []
+
+            sage: t = WeakTableau([[None, None, 2, 3, 4], [1, 4], [2]], 3)
+            sage: t.list_of_standard_cells()
+            Traceback (most recent call last):
+            ...
+            ValueError: This method only works for straight tableaux!
+
+            sage: t = WeakTableau([[1,2],[2]], 3)
+            sage: t.list_of_standard_cells()
+            Traceback (most recent call last):
+            ...
+            ValueError: This method only works for weak tableaux with partition weight!
+        """
+        if self.parent()._skew:
+            raise ValueError("This method only works for straight tableaux!")
+        if self.weight() not in Partitions(sum(self.weight())):
+            raise ValueError("This method only works for weak tableaux with partition weight!")
+        if not self:
+            return []
+        mu = Partition(self.weight()).conjugate()
+        already_used = []
+        out = []
+        for i in range(self[0].count(1)):
+            standard_cells = [(0,self[0].count(1) - i - 1)]
+            r = self[0].count(1) - i - 1
+            for v in range(1,mu[i]):
+                D = self.dictionary_of_coordinates_at_residues(v+1)
+                new_D = {a: b for (a, b) in D.items()
+                         if all(x not in already_used for x in b)}
+                r = (r - min([self.k+1 - (x-r) % (self.k+1) for x in new_D])) % (self.k+1)
+                standard_cells.append(new_D[r][-1])
+                already_used += new_D[r]
+            out.append(standard_cells)
+        return out
+
+    def k_charge(self, algorithm='I'):
+        r"""
+        Return the `k`-charge of ``self``.
+
+        INPUT:
+
+        - ``algorithm`` -- (default: ``'I'``) if "I", computes `k`-charge using the `I`
+          algorithm, otherwise uses the `J`-algorithm
+
+        OUTPUT: nonnegative integer
+
+        For the definition of `k`-charge and the various algorithms to compute it see
+        Section 3.3 of [LLMSSZ2013]_.
+
+        .. SEEALSO:: :meth:`k_charge_I` and :meth:`k_charge_J`
+
+        EXAMPLES::
+
+            sage: t = WeakTableau([[1, 1, 2, 2, 3], [2, 3], [3]], 3)
+            sage: t.k_charge()
+            2
+            sage: t = WeakTableau([[1, 3, 4, 5, 6], [2, 6], [4]], 3)
+            sage: t.k_charge()
+            8
+            sage: t = WeakTableau([[1, 1, 2, 3, 4, 4, 5, 5, 6], [2, 3, 5, 5, 6], [3, 4, 7], [5, 6], [6], [7]], 4)
+            sage: t.k_charge()
+            12
+
+        TESTS::
+
+            sage: T = WeakTableaux(4, [13,9,5,3,2,1,1], [4,3,3,2,2,1,1,1])
+            sage: T.cardinality()
+            6
+            sage: all(t.k_charge_I() == t.k_charge_J() for t in T)
+            True
+        """
+        if algorithm == "I":
+            return self.k_charge_I()
+        return self.k_charge_J()
+
+    def k_charge_I(self):
+        r"""
+        Return the `k`-charge of ``self`` using the `I`-algorithm.
+
+        For the definition of `k`-charge and the `I`-algorithm see Section 3.3 of [LLMSSZ2013]_.
+
+        OUTPUT: nonnegative integer
+
+        .. SEEALSO:: :meth:`k_charge` and :meth:`k_charge_J`
+
+        EXAMPLES::
+
+            sage: t = WeakTableau([[1, 1, 2, 2, 3], [2, 3], [3]], 3)
+            sage: t.k_charge_I()
+            2
+            sage: t = WeakTableau([[1, 3, 4, 5, 6], [2, 6], [4]], 3)
+            sage: t.k_charge_I()
+            8
+            sage: t = WeakTableau([[1, 1, 2, 3, 4, 4, 5, 5, 6], [2, 3, 5, 5, 6], [3, 4, 7], [5, 6], [6], [7]], 4)
+            sage: t.k_charge_I()
+            12
+
+        TESTS::
+
+            sage: t = WeakTableau([[None, None, 1, 1, 4], [1, 4], [3]], 3)
+            sage: t.k_charge_I()
+            Traceback (most recent call last):
+            ...
+            ValueError: k-charge is not defined for skew weak tableaux
+        """
+        if self.parent()._skew:
+            raise ValueError("k-charge is not defined for skew weak tableaux")
+        stt = self.list_of_standard_cells()
+        kch = 0
+        for sw in stt:
+            Ii = 0
+            for r in range(len(sw)-1):
+                if sw[r][1] < sw[r+1][1]:
+                    Ii += 1 + abs(self.parent().diag(sw[r+1],sw[r]))
+                else:
+                    Ii += - abs(self.parent().diag(sw[r],sw[r+1]))
+                kch += Ii
+        return kch
+
+    def k_charge_J(self):
+        r"""
+        Return the `k`-charge of ``self`` using the `J`-algorithm.
+
+        For the definition of `k`-charge and the `J`-algorithm see Section 3.3 of [LLMSSZ2013]_.
+
+        OUTPUT: nonnegative integer
+
+        .. SEEALSO:: :meth:`k_charge` and :meth:`k_charge_I`
+
+        EXAMPLES::
+
+            sage: t = WeakTableau([[1, 1, 2, 2, 3], [2, 3], [3]], 3)
+            sage: t.k_charge_J()
+            2
+            sage: t = WeakTableau([[1, 3, 4, 5, 6], [2, 6], [4]], 3)
+            sage: t.k_charge_J()
+            8
+            sage: t = WeakTableau([[1, 1, 2, 3, 4, 4, 5, 5, 6], [2, 3, 5, 5, 6], [3, 4, 7], [5, 6], [6], [7]], 4)
+            sage: t.k_charge_J()
+            12
+
+        TESTS::
+
+            sage: t = WeakTableau([[None, None, 1, 1, 4], [1, 4], [3]], 3)
+            sage: t.k_charge_I()
+            Traceback (most recent call last):
+            ...
+            ValueError: k-charge is not defined for skew weak tableaux
+
+            sage: t = WeakTableau([[1, 1, 2, 3], [2, 4, 4], [3, 6], [5]], 4, representation='bounded')
+            sage: t.k_charge() == t.k_charge(algorithm = 'J')
+            True
+        """
+        if self.parent()._skew:
+            raise ValueError("k-charge is not defined for skew weak tableaux")
+        stt = self.list_of_standard_cells()
+        kch = 0
+        for sw in stt:
+            Ji = 0
+            for i in range(len(sw)-1):
+                c = (self._height_of_restricted_subword(sw,i+2)+1,0)
+                cdi = self.parent().circular_distance((-c[0]) % (self.k+1),(sw[i][1]-sw[i][0]) % (self.k+1))
+                cdi1 = self.parent().circular_distance((-c[0]) % (self.k+1),(sw[i+1][1]-sw[i+1][0]) % (self.k+1))
+                if (cdi > cdi1):
+                    Ji += 1
+                kch += Ji + self.parent().diag(sw[i+1],c)
+        return kch
+
+    def _height_of_restricted_subword(self, sw, r):
+        r"""
+        Return the row of the highest addable cell of the subtableau of ``self`` with letters `\le r`
+        (excluding letters `r` in standard subwords before ``sw``).
+
+        Restrict the weak `k`-tableau ``self`` to letters `\le r` and remove all letters
+        `r` that appeared in a previous standard subword selected by
+        :meth:`list_of_standard_cells`.
+
+        INPUT:
+
+        - ``sw`` -- one of the subwords of standard cells of ``self``
+        - ``r`` -- nonnegative integer
+
+        OUTPUT: nonnegative integer
+
+        EXAMPLES::
+
+            sage: t = WeakTableau([[1, 1, 2, 2, 3], [2, 3], [3]], 3)
+            sage: s = t.list_of_standard_cells()[0]; s
+            [(0, 1), (1, 0), (2, 0)]
+            sage: t._height_of_restricted_subword(s,2)
+            1
+
+            sage: t = WeakTableau([[1, 3, 4, 5, 6], [2, 6], [4]], 3)
+            sage: s = t.list_of_standard_cells()[0]; s
+            [(0, 0), (1, 0), (0, 1), (2, 0), (0, 3), (1, 1)]
+            sage: t._height_of_restricted_subword(s,4)
+            2
+
+            sage: t = WeakTableau([[1, 1, 2, 3, 4, 4, 5, 5, 6], [2, 3, 5, 5, 6], [3, 4, 7], [5, 6], [6], [7]], 4)
+            sage: s = t.list_of_standard_cells()[0]; s
+            [(0, 1), (1, 0), (2, 0), (0, 5), (3, 0), (4, 0), (5, 0)]
+            sage: t._height_of_restricted_subword(s,6)
+            4
+        """
+        R = [v for v in self.shape().to_partition().cells() if self[v[0]][v[1]] < r]
+        L = [v for v in sw if self[v[0]][v[1]] <= r]
+        return max(v[0] for v in L + R)
+
+
+class WeakTableaux_core(WeakTableaux_abstract):
+    r"""
+    The class of (skew) weak `k`-tableaux in the core representation of shape ``shape``
+    (as `k+1`-core) and weight ``weight``.
+
+    INPUT:
+
+    - ``k`` -- positive integer
+    - ``shape`` -- the shape of the `k`-tableaux represented as a `(k+1)`-core; if the
+      tableaux are skew, the shape is a tuple of the outer and inner shape (both as
+      `(k+1)`-cores)
+    - ``weight`` -- the weight of the `k`-tableaux
+
+    EXAMPLES::
+
+        sage: T = WeakTableaux(3, [4,1], [2,2])
+        sage: T.list()
+        [[[1, 1, 2, 2], [2]]]
+
+        sage: T = WeakTableaux(3, [[5,2,1], [2]], [1,1,1,1])
+        sage: T.list()
+        [[[None, None, 2, 3, 4], [1, 4], [2]],
+        [[None, None, 1, 2, 4], [2, 4], [3]],
+        [[None, None, 1, 2, 3], [2, 3], [4]]]
+    """
+
+    @staticmethod
+    def __classcall_private__(cls, k, shape, weight):
+        r"""
+        Straighten arguments before unique representation.
+
+        TESTS::
+
+            sage: from sage.combinat.k_tableau import WeakTableaux_core
+            sage: T = WeakTableaux_core(3, [2,1], [1,1,1])
+            sage: TestSuite(T).run()
+            sage: T = WeakTableaux_core(3, [[5,2,1], [2]], [1,1,1,1])
+            sage: TestSuite(T).run()
+        """
+        if shape == [] or shape[0] in ZZ:
+            shape = (Core(shape, k+1), Core([],k+1))
+        else:
+            shape = tuple([Core(r,k+1) for r in shape])
+        return super().__classcall__(cls, k, shape, tuple(weight))
+
+    def __init__(self, k, shape, weight):
+        r"""
+        Initialize the parent class of (skew) weak `k`-tableaux in core representation.
+
+        INPUT:
+
+        - ``k`` -- positive integer
+        - ``outer_shape`` -- the outer shape of the `k`-tableaux represented as a
+          `(k+1)`-core
+        - ``weight`` -- the weight of the `k`-tableaux
+        - ``inner_shape`` -- the inner shape of the skew `k`-tableaux represented as a
+          `(k+1)`-core;  for straight tableaux the inner shape does not need to be
+          specified (default: ``[]``)
+
+        TESTS::
+
+            sage: from sage.combinat.k_tableau import WeakTableaux_core
+            sage: T = WeakTableaux_core(3, [4,1], [2,2])
+            sage: TestSuite(T).run()
+            sage: T = WeakTableaux_core(3, [[5,2,1], [2]], [1,1,1,1])
+            sage: TestSuite(T).run()
+        """
+        self.k = k
+        self._skew = bool(shape[1])
+        self._outer_shape = shape[0]
+        self._inner_shape = shape[1]
+        self._shape = (self._outer_shape, self._inner_shape)
+        self._weight = weight
+        self._representation = 'core'
+        Parent.__init__(self, category=FiniteEnumeratedSets())
+
+    def _repr_(self):
+        """
+        TESTS::
+
+            sage: from sage.combinat.k_tableau import WeakTableaux_core
+            sage: repr(WeakTableaux_core(3, [2,1], [1,1,1]))
+            'Core weak 3-Tableaux of (skew) core shape [2, 1] and weight (1, 1, 1)'
+            sage: repr(WeakTableaux_core(3, [[5,2,1], [2]], [1,1,1,1]))
+            'Core weak 3-Tableaux of (skew) core shape ([5, 2, 1], [2]) and weight (1, 1, 1, 1)'
+        """
+        return "Core weak %s-Tableaux of (skew) core shape %s and weight %s" % (self.k, self.shape(), self._weight)
+
+    def __iter__(self):
+        r"""
+        TESTS::
+
+            sage: T = WeakTableaux(3, [4,1], [2,2])
+            sage: T.list()
+            [[[1, 1, 2, 2], [2]]]
+            sage: T = WeakTableaux(3, [5,2,2], [2,2,2,1])
+            sage: T.list()
+            [[[1, 1, 3, 3, 4], [2, 2], [3, 3]], [[1, 1, 2, 2, 3], [2, 3], [3, 4]]]
+            sage: T = WeakTableaux(3, [[5,2,2], [1]], [2,1,2,1])
+            sage: T.list()
+            [[[None, 1, 3, 3, 4], [1, 2], [3, 3]],
+            [[None, 1, 2, 3, 3], [1, 3], [2, 4]],
+            [[None, 1, 1, 2, 3], [2, 3], [3, 4]]]
+        """
+        for t in WeakTableaux_bounded(self.k, [self._outer_shape.to_bounded_partition(), self._inner_shape.to_bounded_partition()], self._weight):
+            yield t.to_core_tableau()
+
+    def diag(self, c, ha):
+        r"""
+        Return the number of diagonals strictly between cells ``c`` and ``ha`` of the same residue as ``c``.
+
+        INPUT:
+
+        - ``c`` -- a cell in the lattice
+        - ``ha`` -- another cell in the lattice with bigger row and smaller column than `c`
+
+        OUTPUT: nonnegative integer
+
+        EXAMPLES::
+
+            sage: T = WeakTableaux(4, [5,2,2], [2,2,2,1])
+            sage: T.diag((1,2),(4,0))
+            0
+        """
+        return divmod((c[1]-c[0])-(ha[1]-ha[0])-1, self.k+1)[0]
+
+    def circular_distance(self, cr, r):
+        r"""
+        Return the shortest counterclockwise distance between ``cr`` and ``r`` modulo `k+1`.
+
+        INPUT:
+
+        - ``cr``, ``r`` -- nonnegative integers between `0` and `k`
+
+        OUTPUT: positive integer
+
+        EXAMPLES::
+
+            sage: T = WeakTableaux(10, [], [])
+            sage: T.circular_distance(8, 6)
+            2
+            sage: T.circular_distance(8, 8)
+            0
+            sage: T.circular_distance(8, 9)
+            10
+        """
+        return self.k - ((r+self.k-cr) % (self.k+1))
+
+    Element = WeakTableau_core
+
+
+#Weak tableaux in terms of `k`-bounded partitions
+class WeakTableau_bounded(WeakTableau_abstract):
+    r"""
+    A (skew) weak `k`-tableau represented in terms of `k`-bounded partitions.
+    """
+    @staticmethod
+    def __classcall_private__(cls, t, k):
+        r"""
+        Implement the shortcut ``WeakTableau_bounded(t, k)`` to
+        ``WeakTableaux_bounded(k, shape, weight)(t)`` where ``shape`` is the
+        shape of the tableau and ``weight`` is its weight.
+
+        TESTS::
+
+            sage: from sage.combinat.k_tableau import WeakTableau_bounded
+            sage: t = WeakTableau_bounded([[1,1,2],[2,3],[3]],3)
+            sage: t.check()
+            sage: type(t)
+            <class 'sage.combinat.k_tableau.WeakTableaux_bounded_with_category.element_class'>
+            sage: TestSuite(t).run()
+            sage: t.parent()._skew
+            False
+
+            sage: t = WeakTableau_bounded([[None, None, 1], [1, 2], [2]], 3)
+            sage: t.check()
+            sage: type(t)
+            <class 'sage.combinat.k_tableau.WeakTableaux_bounded_with_category.element_class'>
+            sage: TestSuite(t).run()
+            sage: t.parent()._skew
+            True
+        """
+        if isinstance(t, cls):
+            return t
+        tab = SkewTableau(list(t))
+        outer = tab.outer_shape()
+        inner = tab.inner_shape()
+        weight = tuple(tab.weight())
+        if outer.conjugate().length() > k:
+            raise ValueError("The shape of %s is not %s-bounded" % (t, k))
+        return WeakTableaux_bounded(k, [outer, inner], weight)(t)
+
+    def __init__(self, parent, t):
+        r"""
+        Initialization of (skew) weak `k`-tableau ``t`` in `k`-bounded representation.
+
+        INPUT:
+
+        - ``t`` -- weak tableau in `k`-bounded representation; the input is supposed to be
+          a list of iterables specifying the rows of the tableau;  ``None`` is allowed as an
+          entry for skew weak `k`-tableaux
+
+        TESTS::
+
+            sage: from sage.combinat.k_tableau import WeakTableau_bounded, WeakTableaux_bounded
+            sage: c = WeakTableau_bounded([[1,1,2],[2,3],[3]],3)
+            sage: T = WeakTableaux_bounded(3,[3,2,1],[2,2,2])
+            sage: t = T([[1,1,2],[2,3],[3]]); t
+            [[1, 1, 2], [2, 3], [3]]
+            sage: c == t
+            True
+            sage: type(t)
+            <class 'sage.combinat.k_tableau.WeakTableaux_bounded_with_category.element_class'>
+            sage: t.parent()
+            Bounded weak 3-Tableaux of (skew) 3-bounded shape [3, 2, 1] and weight (2, 2, 2)
+            sage: TestSuite(t).run()
+
+            sage: t = WeakTableau_bounded([[None, None, 1], [2, 4], [3]], 3)
+            sage: t.shape()
+            ([3, 2, 1], [2])
+            sage: t.weight()
+            (1, 1, 1, 1)
+            sage: TestSuite(t).run()
+
+            sage: t = T([[1,1,3],[2,2],[3]])
+            Traceback (most recent call last):
+            ...
+            ValueError: This is not a proper weak 3-tableau
+        """
+        k = parent.k
+        self.k = k
+        if parent._outer_shape.conjugate().length() > k:
+            raise ValueError("%s is not a %s-bounded tableau" % (t, k))
+        ClonableList.__init__(self, parent, [list(r) for r in t])
+
+    def _repr_diagram(self):
+        r"""
+        Return a string representation of ``self`` as a diagram.
+
+        EXAMPLES::
+
+            sage: t = WeakTableau([[None, None, 1], [2, 4], [3]], 3, representation = 'bounded')
+            sage: print(t._repr_diagram())
+            .  .  1
+            2  4
+            3
+            sage: t = WeakTableau([[1,1,1],[2,2],[3]], 3, representation = 'bounded')
+            sage: print(t._repr_diagram())
+            1  1  1
+            2  2
+            3
+        """
+        t = SkewTableau(list(self))
+        return t._repr_diagram()
+
+    def shape_core(self):
+        r"""
+        Return the shape of ``self`` as `(k+1)`-core.
+
+        When the tableau is straight, the outer shape is returned as a `(k+1)`-core.
+        When the tableau is skew, the tuple of the outer and inner shape is returned as
+        `(k+1)`-cores.
+
+        EXAMPLES::
+
+            sage: t = WeakTableau([[1,1,1],[2,2],[3]], 3, representation = 'bounded')
+            sage: t.shape_core()
+            [5, 2, 1]
+
+            sage: t = WeakTableau([[None, None, 1], [2, 4], [3]], 3, representation = 'bounded')
+            sage: t.shape_core()
+            ([5, 2, 1], [2])
+        """
+        if self.parent()._skew:
+            return tuple([r.to_core(self.k) for r in self.shape_bounded()])
+        return self.shape_bounded().to_core(self.k)
+
+    def shape_bounded(self):
+        r"""
+        Return the shape of ``self`` as `k`-bounded partition.
+
+        When the tableau is straight, the outer shape is returned as a `k`-bounded
+        partition.  When the tableau is skew, the tuple of the outer and inner shape is
+        returned as `k`-bounded partitions.
+
+        EXAMPLES::
+
+            sage: t = WeakTableau([[1,1,1],[2,2],[3]], 3, representation = 'bounded')
+            sage: t.shape_bounded()
+            [3, 2, 1]
+
+            sage: t = WeakTableau([[None, None, 1], [2, 4], [3]], 3, representation = 'bounded')
+            sage: t.shape_bounded()
+            ([3, 2, 1], [2])
+        """
+        return self.shape()
+
+    def check(self):
+        r"""
+        Check that ``self`` is a valid weak `k`-tableau.
+
+        EXAMPLES::
+
+            sage: t = WeakTableau([[1,1],[2]], 2, representation = 'bounded')
+            sage: t.check()
+
+            sage: t = WeakTableau([[None, None, 1], [2, 4], [3]], 3, representation = 'bounded')
+            sage: t.check()
+
+        TESTS::
+
+            sage: t = WeakTableau([[1,1,3],[2,2],[3]], 3, representation = 'bounded')
+            Traceback (most recent call last):
+            ...
+            ValueError: This is not a proper weak 3-tableau
+
+            sage: T = WeakTableaux(3, [3,1], [2,1], representation = 'bounded')
+            sage: t = T([[None, 1,1], [2]])
+            Traceback (most recent call last):
+            ...
+            ValueError: The inner shape of the parent does not agree with the inner shape of the tableau!
+
+            sage: t = WeakTableau([[1,1],[1]], 3, representation = 'bounded')
+            Traceback (most recent call last):
+            ...
+            ValueError: The tableaux is not semistandard!
+        """
+        t = SkewTableau(list(self))
+        if t not in SemistandardSkewTableaux():
+            raise ValueError("The tableaux is not semistandard!")
+        if not self.parent()._weight == tuple(t.weight()):
+            raise ValueError("The weight of the parent does not agree with the weight of the tableau!")
+        outer = t.outer_shape()
+        inner = t.inner_shape()
+        if self.parent()._outer_shape != outer:
+            raise ValueError("The outer shape of the parent does not agree with the outer shape of the tableau!")
+        if self.parent()._inner_shape != inner:
+            raise ValueError("The inner shape of the parent does not agree with the inner shape of the tableau!")
+        if not t.is_k_tableau(self.k):
+            raise ValueError("This is not a proper weak %s-tableau" % (self.k))
+
+    def _is_k_tableau(self):
+        r"""
+        Check whether ``self`` is a valid weak `k`-tableau.
+
+        EXAMPLES::
+
+            sage: t = WeakTableau([[1,1,1],[2,2],[3]], 3, representation = 'bounded')
+            sage: t._is_k_tableau()
+            True
+
+            sage: t = WeakTableau([[None, None, 1], [2, 4], [3]], 3, representation = 'bounded')
+            sage: t._is_k_tableau()
+            True
+        """
+        shapes = self.intermediate_shapes()
+        kshapes = [ la.k_conjugate(self.k) for la in shapes ]
+        return all( kshapes[i+1].contains(kshapes[i]) for i in range(len(shapes)-1) )
+
+    def to_core_tableau(self):
+        r"""
+        Return the weak `k`-tableau ``self`` where the shape of each restricted tableau is a `(k+1)`-core.
+
+        EXAMPLES::
+
+            sage: t = WeakTableau([[1,1,2,4],[2,3,5],[3,4],[5,6],[6],[7]], 4, representation = 'bounded')
+            sage: c = t.to_core_tableau(); c
+            [[1, 1, 2, 3, 4, 4, 5, 5, 6], [2, 3, 5, 5, 6], [3, 4, 7], [5, 6], [6], [7]]
+            sage: type(c)
+            <class 'sage.combinat.k_tableau.WeakTableaux_core_with_category.element_class'>
+            sage: t = WeakTableau([], 4, representation = 'bounded')
+            sage: t.to_core_tableau()
+            []
+
+            sage: from sage.combinat.k_tableau import WeakTableau_bounded
+            sage: t = WeakTableau([[1,1,2],[2,3],[3]], 3, representation = 'bounded')
+            sage: WeakTableau_bounded.from_core_tableau(t.to_core_tableau(),3)
+            [[1, 1, 2], [2, 3], [3]]
+            sage: t == WeakTableau_bounded.from_core_tableau(t.to_core_tableau(),3)
+            True
+
+            sage: t = WeakTableau([[None, None, 1], [2, 4], [3]], 3, representation = 'bounded')
+            sage: t.to_core_tableau()
+            [[None, None, 1, 2, 4], [2, 4], [3]]
+            sage: t == WeakTableau_bounded.from_core_tableau(t.to_core_tableau(),3)
+            True
+        """
+        shapes = [ p.to_core(self.k) for p in self.intermediate_shapes() ]
+        if self.parent()._skew:
+            l = [[None]*i for i in shapes[0]]
+        else:
+            l = []
+        for i in range(1,len(shapes)):
+            p = shapes[i]
+            if len(l) < len(p):
+                l += [[]]
+            l_new = []
+            for j in range(len(l)):
+                l_new += [l[j] + [i]*(p[j]-len(l[j]))]
+            l = l_new
+        return WeakTableau_core(l, self.k)
+
+    @classmethod
+    def from_core_tableau(cls, t, k):
+        r"""
+        Construct weak `k`-bounded tableau from in `k`-core tableau.
+
+        EXAMPLES::
+
+            sage: from sage.combinat.k_tableau import WeakTableau_bounded
+            sage: WeakTableau_bounded.from_core_tableau([[1, 1, 2, 2, 3], [2, 3], [3]], 3)
+            [[1, 1, 2], [2, 3], [3]]
+
+            sage: WeakTableau_bounded.from_core_tableau([[None, None, 2, 3, 4], [1, 4], [2]], 3)
+            [[None, None, 3], [1, 4], [2]]
+
+            sage: WeakTableau_bounded.from_core_tableau([[None,2,3],[3]], 2)
+            [[None, 2], [3]]
+        """
+        t = SkewTableau(list(t))
+        shapes = [ Core(p, k+1).to_bounded_partition() for p in intermediate_shapes(t) ]  # .to_chain() ]
+        if t.inner_shape() == Partition([]):
+            l = []
+        else:
+            l = [[None]*i for i in shapes[0]]
+        for i in range(1, len(shapes)):
+            p = shapes[i]
+            if len(l) < len(p):
+                l += [[]]
+            l_new = []
+            for j in range(len(l)):
+                l_new += [l[j] + [i]*(p[j]-len(l[j]))]
+            l = l_new
+        return cls(l, k)
+
+    def k_charge(self, algorithm='I'):
+        r"""
+        Return the `k`-charge of ``self``.
+
+        INPUT:
+
+        - ``algorithm`` -- (default: ``'I'``) if "I", computes `k`-charge using the `I`
+          algorithm, otherwise uses the `J`-algorithm
+
+        OUTPUT: nonnegative integer
+
+        For the definition of `k`-charge and the various algorithms to compute it see Section 3.3 of [LLMSSZ2013]_.
+
+        EXAMPLES::
+
+            sage: t = WeakTableau([[1, 1, 2], [2, 3], [3]], 3, representation = 'bounded')
+            sage: t.k_charge()
+            2
+            sage: t = WeakTableau([[1, 3, 5], [2, 6], [4]], 3, representation = 'bounded')
+            sage: t.k_charge()
+            8
+            sage: t = WeakTableau([[1, 1, 2, 4], [2, 3, 5], [3, 4], [5, 6], [6], [7]], 4, representation = 'bounded')
+            sage: t.k_charge()
+            12
+        """
+        return self.to_core_tableau().k_charge(algorithm=algorithm)
+
+
+class WeakTableaux_bounded(WeakTableaux_abstract):
+    r"""
+    The class of (skew) weak `k`-tableaux in the bounded representation of shape ``shape``
+    (as `k`-bounded partition or tuple of `k`-bounded partitions in the skew case) and
+    weight ``weight``.
+
+    INPUT:
+
+    - ``k`` -- positive integer
+    - ``shape`` -- the shape of the `k`-tableaux represented as a `k`-bounded partition;
+      if the tableaux are skew, the shape is a tuple of the outer and inner shape each
+      represented as a `k`-bounded partition
+    - ``weight`` -- the weight of the `k`-tableaux
+
+    EXAMPLES::
+
+        sage: T = WeakTableaux(3, [3,1], [2,2], representation = 'bounded')
+        sage: T.list()
+        [[[1, 1, 2], [2]]]
+
+        sage: T = WeakTableaux(3, [[3,2,1], [2]], [1,1,1,1], representation = 'bounded')
+        sage: T.list()
+        [[[None, None, 3], [1, 4], [2]],
+        [[None, None, 1], [2, 4], [3]],
+        [[None, None, 1], [2, 3], [4]]]
+    """
+    @staticmethod
+    def __classcall_private__(cls, k, shape, weight):
+        r"""
+        Straighten arguments before unique representation.
+
+        TESTS::
+
+            sage: from sage.combinat.k_tableau import WeakTableaux_bounded
+            sage: T = WeakTableaux_bounded(3, [2,1], [1,1,1])
+            sage: TestSuite(T).run()
+            sage: T = WeakTableaux_bounded(3, [[3,2,1], [2]], [1,1,1,1])
+            sage: TestSuite(T).run()
+        """
+        if shape == [] or shape[0] in ZZ:
+            shape = (Partition(shape), Partition([]))
+        else:
+            shape = tuple([Partition(r) for r in shape])
+        return super().__classcall__(cls, k, shape, tuple(weight))
+
+    def __init__(self, k, shape, weight):
+        r"""
+        Initialize the parent class of (skew) weak `k`-tableaux in bounded representation.
+
+        INPUT:
+
+        - ``k`` -- positive integer
+        - ``shape`` -- the shape of the `k`-tableaux represented as a `k`-bounded
+          partition; if the tableaux are skew, the shape is a tuple of the outer and inner
+          shape each represented as a `k`-bounded partition
+        - ``weight`` -- the weight of the `k`-tableaux
+
+        TESTS::
+
+            sage: from sage.combinat.k_tableau import WeakTableaux_bounded
+            sage: T = WeakTableaux_bounded(3, [3,1], [2,2])
+            sage: TestSuite(T).run()
+            sage: T = WeakTableaux_bounded(3, [[3,2,1], [2]], [1,1,1,1])
+            sage: TestSuite(T).run()
+        """
+        self.k = k
+        self._skew = bool(shape[1])
+        self._outer_shape = Partition(shape[0])
+        self._inner_shape = Partition(shape[1])
+        self._shape = (self._outer_shape, self._inner_shape)
+        self._weight = tuple(weight)
+        self._representation = 'bounded'
+        Parent.__init__(self, category=FiniteEnumeratedSets())
+
+    def _repr_(self):
+        """
+        TESTS::
+
+            sage: from sage.combinat.k_tableau import WeakTableaux_bounded
+            sage: repr(WeakTableaux_bounded(3, [2,1], [1,1,1]))
+            'Bounded weak 3-Tableaux of (skew) 3-bounded shape [2, 1] and weight (1, 1, 1)'
+            sage: repr(WeakTableaux_bounded(3, [[3,2,1], [2]], [1,1,1,1]))
+            'Bounded weak 3-Tableaux of (skew) 3-bounded shape ([3, 2, 1], [2]) and weight (1, 1, 1, 1)'
+        """
+        return "Bounded weak %s-Tableaux of (skew) %s-bounded shape %s and weight %s" % (self.k, self.k, self.shape(), self._weight)
+
+    def __iter__(self):
+        r"""
+        TESTS::
+
+            sage: T = WeakTableaux(3, [3,1], [2,2], representation = 'bounded')
+            sage: T.list()
+            [[[1, 1, 2], [2]]]
+            sage: T = WeakTableaux(3, [3,2,2], [2,2,2,1], representation = 'bounded')
+            sage: T.list()
+            [[[1, 1, 4], [2, 2], [3, 3]], [[1, 1, 2], [2, 3], [3, 4]]]
+            sage: T = WeakTableaux(3, [[3,2,2], [1]], [2,1,2,1], representation = 'bounded')
+            sage: T.list()
+            [[[None, 1, 4], [1, 2], [3, 3]],
+            [[None, 1, 3], [1, 3], [2, 4]],
+            [[None, 1, 1], [2, 3], [3, 4]]]
+        """
+        for t in SemistandardSkewTableaux([self._outer_shape, self._inner_shape], self._weight):
+            if t.is_k_tableau(self.k):
+                yield self(t)
+
+    Element = WeakTableau_bounded
+
+#Weak tableaux in terms of factorized permutations
+
+
+class WeakTableau_factorized_permutation(WeakTableau_abstract):
+    r"""
+    A weak (skew) `k`-tableau represented in terms of factorizations of affine
+    permutations into cyclically decreasing elements.
+    """
+    @staticmethod
+    def straighten_input(t, k):
+        r"""
+        Straightens input.
+
+        INPUT:
+
+        - ``t`` -- list of reduced words or a list of elements in the Weyl group of type
+          `A_k^{(1)}`
+        - ``k`` -- positive integer
+
+        EXAMPLES::
+
+            sage: from sage.combinat.k_tableau import WeakTableau_factorized_permutation
+            sage: WeakTableau_factorized_permutation.straighten_input([[2,0],[3,2],[1,0]], 3)
+            (s2*s0, s3*s2, s1*s0)
+            sage: W = WeylGroup(['A',4,1])
+            sage: WeakTableau_factorized_permutation.straighten_input([W.an_element(),W.an_element()], 4)
+            (s0*s1*s2*s3*s4, s0*s1*s2*s3*s4)
+
+        TESTS::
+
+            sage: WeakTableau_factorized_permutation.straighten_input([W.an_element(),W.an_element()], 3)
+            Traceback (most recent call last):
+            ...
+            ValueError: inconsistent number of rows: should be 4 but got 5
+        """
+        W = WeylGroup(['A', k, 1], prefix='s')
+        if len(t) > 0:
+            if isinstance(t[0], (list, tuple)):
+                w_tuple = tuple(W.from_reduced_word(p) for p in t)
+            else:
+                w_tuple = tuple(W(r) for r in t)
+        else:
+            w_tuple = tuple([W.one()])
+        return w_tuple
+
+    @staticmethod
+    def __classcall_private__(cls, t, k, inner_shape=[]):
+        r"""
+        Implement the shortcut ``WeakTableau_factorized_permutation(t, k)`` to
+        ``WeakTableaux_factorized_permutation(k, shape, weight)(t)``
+        where ``shape`` is the shape of the tableau as a `(k+1)`-core (or a tuple of
+        `(k+1)`-cores if the tableau is skew) and ``weight`` is its weight.
+
+        TESTS::
+
+            sage: from sage.combinat.k_tableau import WeakTableau_factorized_permutation
+            sage: t = WeakTableau_factorized_permutation([[2,0],[3,2],[1,0]], 3)
+            sage: t.check()
+            sage: type(t)
+            <class 'sage.combinat.k_tableau.WeakTableaux_factorized_permutation_with_category.element_class'>
+            sage: TestSuite(t).run()
+
+            sage: t = WeakTableau_factorized_permutation([[0,3],[2,1]], 3, inner_shape = [1,1])
+            sage: t.check()
+            sage: TestSuite(t).run()
+
+            sage: t = WeakTableau_factorized_permutation([], 3); t
+            [1]
+            sage: t.check()
+            sage: TestSuite(t).run()
+        """
+        if isinstance(t, cls):
+            return t
+        W = WeylGroup(['A', k, 1], prefix='s')
+        w = cls.straighten_input(t, k)
+        weight = tuple(w[i].length() for i in range(len(w) - 1, -1, -1))
+        inner_shape = Core(inner_shape, k + 1)
+        outer_shape = (W.prod(w)*W(inner_shape.to_grassmannian())).affine_grassmannian_to_core()
+        return WeakTableaux_factorized_permutation(k, [outer_shape, inner_shape], weight)(w)
+
+    def __init__(self, parent, t):
+        r"""
+        Initialization of (skew) weak `k`-tableau ``t`` in factorized permutation representation.
+
+        INPUT:
+
+        - ``t`` -- (skew) weak tableau in factorized permutation representation; the input
+          can either be a list of reduced words of cyclically decreasing elements, or a
+          list of cyclically decreasing elements;  when the tableau is skew, the inner
+          shape needs to be specified as a `(k+1)`-core
+
+        TESTS::
+
+            sage: from sage.combinat.k_tableau import WeakTableau_factorized_permutation, WeakTableaux_factorized_permutation
+            sage: c = WeakTableau_factorized_permutation([[2,0],[3,2],[1,0]], 3)
+            sage: T = WeakTableaux_factorized_permutation(3, [5,2,1],[2,2,2])
+            sage: t = T([[2,0],[3,2],[1,0]]); t
+            [s2*s0, s3*s2, s1*s0]
+            sage: c == t
+            True
+            sage: type(t)
+            <class 'sage.combinat.k_tableau.WeakTableaux_factorized_permutation_with_category.element_class'>
+            sage: t.parent()
+            Factorized permutation (skew) weak 3-Tableaux of shape [5, 2, 1] and weight (2, 2, 2)
+            sage: TestSuite(t).run()
+
+            sage: t = WeakTableau_factorized_permutation([[2,0],[3,2]], 3, inner_shape = [2]); t
+            [s2*s0, s3*s2]
+            sage: t._inner_shape
+            [2]
+            sage: t.weight()
+            (2, 2)
+            sage: t.shape()
+            ([5, 2, 1], [2])
+            sage: TestSuite(t).run()
+
+            sage: t = T([[3,0],[0,3],[1,0]])
+            Traceback (most recent call last):
+            ...
+            ValueError: The outer shape of the parent does not agree with the outer shape of the tableau!
+
+            sage: t = WeakTableau_factorized_permutation([], 3); t
+            [1]
+            sage: t.parent()._outer_shape
+            []
+            sage: t.parent()._weight
+            (0,)
+        """
+        self.k = parent.k
+        self._inner_shape = parent._inner_shape
+        ClonableList.__init__(self, parent, self.straighten_input(t, parent.k))
+
+    def shape_core(self):
+        r"""
+        Return the shape of ``self`` as a `(k+1)`-core.
+
+        When the tableau is straight, the outer shape is returned as a core.
+        When the tableau is skew, the tuple of the outer and inner shape is returned as
+        cores.
+
+        EXAMPLES::
+
+            sage: t = WeakTableau([[2],[0,3],[2,1,0]], 3, representation = 'factorized_permutation')
+            sage: t.shape_core()
+            [5, 2, 1]
+
+            sage: t = WeakTableau([[2,0],[3,2]], 3, inner_shape = [2], representation = 'factorized_permutation')
+            sage: t.shape()
+            ([5, 2, 1], [2])
+        """
+        return self.shape()
+
+    def shape_bounded(self):
+        r"""
+        Return the shape of ``self`` as a `k`-bounded partition.
+
+        When the tableau is straight, the outer shape is returned as a `k`-bounded
+        partition.  When the tableau is skew, the tuple of the outer and inner shape is
+        returned as `k`-bounded partitions.
+
+        EXAMPLES::
+
+            sage: t = WeakTableau([[2],[0,3],[2,1,0]], 3, representation = 'factorized_permutation')
+            sage: t.shape_bounded()
+            [3, 2, 1]
+
+            sage: t = WeakTableau([[2,0],[3,2]], 3, inner_shape = [2], representation = 'factorized_permutation')
+            sage: t.shape_bounded()
+            ([3, 2, 1], [2])
+        """
+        if self.parent()._skew:
+            return tuple([r.to_bounded_partition() for r in self.shape_core()])
+        return self.shape_core().to_bounded_partition()
+
+    def check(self):
+        r"""
+        Check that ``self`` is a valid weak `k`-tableau.
+
+        EXAMPLES::
+
+            sage: t = WeakTableau([[2],[0,3],[2,1,0]], 3, representation = 'factorized_permutation')
+            sage: t.check()
+
+        TESTS::
+
+            sage: t = WeakTableau([[2,0],[3,2]], 3, representation = 'factorized_permutation')
+            Traceback (most recent call last):
+            ...
+            ValueError: this only works on type 'A' affine Grassmannian elements
+
+            sage: T = WeakTableaux(3, [4,1], [2,1], representation = 'factorized_permutation')
+            sage: t = T([[2],[1],[0]])
+            Traceback (most recent call last):
+            ...
+            ValueError: The weight of the parent does not agree with the weight of the tableau!
+        """
+        weight = tuple(self[i].length() for i in range(len(self) - 1, -1, -1))
+        if not self.parent()._weight == weight:
+            raise ValueError("The weight of the parent does not agree "
+                             "with the weight of the tableau!")
+        W = self[0].parent()
+        outer = (W.prod(self)*W((self._inner_shape).to_grassmannian())).affine_grassmannian_to_core()
+        if self.parent()._outer_shape != outer:
+            raise ValueError("The outer shape of the parent does not agree with the outer shape of the tableau!")
+        if not self._is_k_tableau():
+            raise ValueError("This is not a proper weak %s-tableau" % (self.k))
+
+    def _is_k_tableau(self):
+        r"""
+        Check whether ``self`` is a valid weak `k`-tableau.
+
+        EXAMPLES::
+
+            sage: t = WeakTableau([[2],[0,3],[2,1,0]], 3, representation = 'factorized_permutation')
+            sage: t._is_k_tableau()
+            True
+
+            sage: t = WeakTableau([[2,0],[3,2]], 3, inner_shape = [2], representation = 'factorized_permutation')
+            sage: t._is_k_tableau()
+            True
+        """
+        W = self[0].parent()
+        if (W.prod(self)*W(self.parent()._inner_shape.to_grassmannian())).is_affine_grassmannian():
+            return all( r.is_pieri_factor() for r in self )
+        return False
+
+    def to_core_tableau(self):
+        r"""
+        Return the weak `k`-tableau ``self`` where the shape of each restricted tableau is a `(k+1)`-core.
+
+        EXAMPLES::
+
+            sage: t = WeakTableau([[0], [3,1], [2,1], [0,4], [3,0], [4,2], [1,0]], 4, representation = 'factorized_permutation'); t
+            [s0, s3*s1, s2*s1, s0*s4, s3*s0, s4*s2, s1*s0]
+            sage: c = t.to_core_tableau(); c
+            [[1, 1, 2, 3, 4, 4, 5, 5, 6], [2, 3, 5, 5, 6], [3, 4, 7], [5, 6], [6], [7]]
+            sage: type(c)
+            <class 'sage.combinat.k_tableau.WeakTableaux_core_with_category.element_class'>
+            sage: t = WeakTableau([[]], 4, representation = 'factorized_permutation'); t
+            [1]
+            sage: t.to_core_tableau()
+            []
+
+            sage: from sage.combinat.k_tableau import WeakTableau_factorized_permutation
+            sage: t = WeakTableau([[2,0],[3,2],[1,0]], 3, representation = 'factorized_permutation')
+            sage: WeakTableau_factorized_permutation.from_core_tableau(t.to_core_tableau(), 3)
+            [s2*s0, s3*s2, s1*s0]
+            sage: t == WeakTableau_factorized_permutation.from_core_tableau(t.to_core_tableau(), 3)
+            True
+
+            sage: t = WeakTableau([[2,0],[3,2]], 3, inner_shape = [2], representation = 'factorized_permutation')
+            sage: t.to_core_tableau()
+            [[None, None, 1, 1, 2], [1, 2], [2]]
+            sage: t == WeakTableau_factorized_permutation.from_core_tableau(t.to_core_tableau(), 3)
+            True
+        """
+        W = self[0].parent()
+        factor = W(self._inner_shape.to_grassmannian())
+        shapes = [factor]
+        for i in range(len(self)-1,-1,-1):
+            factor = self[i]*factor
+            shapes += [factor.affine_grassmannian_to_core()]
+        if self.parent()._skew:
+            l = [[None]*i for i in self._inner_shape]
+        else:
+            l = []
+        for i in range(1,len(shapes)):
+            p = shapes[i]
+            if len(l) < len(p):
+                l += [[]]
+            l_new = []
+            for j in range(len(l)):
+                l_new += [l[j] + [i]*(p[j]-len(l[j]))]
+            l = l_new
+        return WeakTableau_core(l, self.k)
+
+    @classmethod
+    def from_core_tableau(cls, t, k):
+        r"""
+        Construct weak factorized affine permutation tableau from a `k`-core tableau.
+
+        EXAMPLES::
+
+            sage: from sage.combinat.k_tableau import WeakTableau_factorized_permutation
+            sage: WeakTableau_factorized_permutation.from_core_tableau([[1, 1, 2, 2, 3], [2, 3], [3]],3)
+            [s2*s0, s3*s2, s1*s0]
+            sage: WeakTableau_factorized_permutation.from_core_tableau([[1, 1, 2, 3, 4, 4, 5, 5, 6], [2, 3, 5, 5, 6], [3, 4, 7], [5, 6], [6], [7]], 4)
+            [s0, s3*s1, s2*s1, s0*s4, s3*s0, s4*s2, s1*s0]
+            sage: WeakTableau_factorized_permutation.from_core_tableau([[None, 1, 1, 2, 2], [None, 2], [1]], 3)
+            [s0*s3, s2*s1]
+        """
+        t = SkewTableau(list(t))
+        shapes = [Core(p, k + 1).to_grassmannian()
+                  for p in intermediate_shapes(t)]  # t.to_chain() ]
+        perms = [shapes[i] * (shapes[i - 1].inverse())
+                 for i in range(len(shapes) - 1, 0, -1)]
+        return cls(perms, k, inner_shape=t.inner_shape())
+
+    def k_charge(self, algorithm='I'):
+        r"""
+        Return the `k`-charge of ``self``.
+
+        OUTPUT: nonnegative integer
+
+        EXAMPLES::
+
+            sage: t = WeakTableau([[2,0],[3,2],[1,0]], 3, representation = 'factorized_permutation')
+            sage: t.k_charge()
+            2
+            sage: t = WeakTableau([[0],[3],[2],[1],[3],[0]], 3, representation = 'factorized_permutation')
+            sage: t.k_charge()
+            8
+            sage: t = WeakTableau([[0],[3,1],[2,1],[0,4],[3,0],[4,2],[1,0]], 4, representation = 'factorized_permutation')
+            sage: t.k_charge()
+            12
+        """
+        return self.to_core_tableau().k_charge(algorithm=algorithm)
+
+
+class WeakTableaux_factorized_permutation(WeakTableaux_abstract):
+    r"""
+    The class of (skew) weak `k`-tableaux in the factorized permutation representation of shape ``shape`` (as `k+1`-core
+    or tuple of `(k+1)`-cores in the skew case) and weight ``weight``.
+
+    INPUT:
+
+    - ``k`` -- positive integer
+    - ``shape`` -- the shape of the `k`-tableaux represented as a `(k+1)`-core;
+      in the skew case the shape is a tuple of the outer and inner shape both as `(k+1)`-cores
+    - ``weight`` -- the weight of the `k`-tableaux
+
+    EXAMPLES::
+
+        sage: T = WeakTableaux(3, [4,1], [2,2], representation = 'factorized_permutation')
+        sage: T.list()
+        [[s3*s2, s1*s0]]
+
+        sage: T = WeakTableaux(4, [[6,2,1], [2]], [2,1,1,1], representation = 'factorized_permutation')
+        sage: T.list()
+        [[s0, s4, s3, s4*s2], [s0, s3, s4, s3*s2], [s3, s0, s4, s3*s2]]
+    """
+    @staticmethod
+    def __classcall_private__(cls, k, shape, weight):
+        r"""
+        Straighten arguments before unique representation.
+
+        TESTS::
+
+            sage: from sage.combinat.k_tableau import WeakTableaux_factorized_permutation
+            sage: T = WeakTableaux_factorized_permutation(3, [2,1], [1,1,1])
+            sage: TestSuite(T).run()
+            sage: T = WeakTableaux_factorized_permutation(4, [[6,2,1], [2]], [2,1,1,1])
+            sage: TestSuite(T).run() # long time
+        """
+        if shape == [] or shape[0] in ZZ:
+            shape = (Core(shape, k+1), Core([],k+1))
+        else:
+            shape = tuple([Core(r,k+1) for r in shape])
+        return super().__classcall__(cls, k, shape, tuple(weight))
+
+    def __init__(self, k, shape, weight):
+        r"""
+        Initialize the parent class of weak `k`-tableaux in factorized permutation representation.
+
+        INPUT:
+
+        - ``k`` -- positive integer
+        - ``shape`` -- the shape of the `k`-tableaux represented as a `(k+1)`-core;
+          in the skew case the shape is a tuple of the outer and inner shape both as
+          `(k+1)`-cores
+        - ``weight`` -- the weight of the `k`-tableaux
+
+        TESTS::
+
+            sage: from sage.combinat.k_tableau import WeakTableaux_factorized_permutation
+            sage: T = WeakTableaux_factorized_permutation(3, [4,1], [2,2])
+            sage: TestSuite(T).run()
+            sage: T = WeakTableaux_factorized_permutation(4, [[6,2,1], [2]], [2,1,1,1])
+            sage: TestSuite(T).run() # long time
+        """
+        self.k = k
+        self._skew = bool(shape[1])
+        self._outer_shape = Core(shape[0], k+1)
+        self._inner_shape = Core(shape[1], k+1)
+        self._shape = (self._outer_shape, self._inner_shape)
+        self._weight = weight
+        self._representation = 'factorized_permutation'
+        Parent.__init__(self, category=FiniteEnumeratedSets())
+
+    def _repr_(self):
+        """
+        TESTS::
+
+            sage: from sage.combinat.k_tableau import WeakTableaux_factorized_permutation
+            sage: repr(WeakTableaux_factorized_permutation(3, [2,1], [1,1,1]))
+            'Factorized permutation (skew) weak 3-Tableaux of shape [2, 1] and weight (1, 1, 1)'
+            sage: repr(WeakTableaux_factorized_permutation(4, [[6,2,1], [2]], [2,1,1,1]))
+            'Factorized permutation (skew) weak 4-Tableaux of shape ([6, 2, 1], [2]) and weight (2, 1, 1, 1)'
+        """
+        return "Factorized permutation (skew) weak %s-Tableaux of shape %s and weight %s" % (self.k, self.shape(), self._weight)
+
+    def __iter__(self):
+        r"""
+        TESTS::
+
+            sage: T = WeakTableaux(3, [4,1], [2,2], representation = 'factorized_permutation')
+            sage: T.list()
+            [[s3*s2, s1*s0]]
+            sage: T = WeakTableaux(3, [5,2,2], [2,2,2,1], representation = 'factorized_permutation')
+            sage: T.list()
+            [[s0, s3*s2, s0*s3, s1*s0], [s3, s2*s0, s3*s2, s1*s0]]
+            sage: T = WeakTableaux(4, [[6,2,1], [2]], [2,1,1,1], representation = 'factorized_permutation')
+            sage: T.list()
+            [[s0, s4, s3, s4*s2], [s0, s3, s4, s3*s2], [s3, s0, s4, s3*s2]]
+        """
+        for t in WeakTableaux_core(self.k, self.shape(), self._weight):
+            yield WeakTableau_factorized_permutation.from_core_tableau(t, self.k)
+
+    Element = WeakTableau_factorized_permutation
+
+
+######## END weak tableaux BEGIN strong tableaux
+
+class StrongTableau(ClonableList, metaclass=InheritComparisonClasscallMetaclass):
+    r"""
+    A (standard) strong `k`-tableau is a (saturated) chain in Bruhat order.
+
+    Combinatorially, it is a sequence of embedded `k+1`-cores (subject to some conditions)
+    together with a set of markings.
+
+    A strong cover in terms of cores corresponds to certain translated ribbons. A marking
+    corresponds to the choice of one of the translated ribbons, which is indicated by
+    marking the head (southeast most cell in French notation) of the chosen ribbon.  For
+    more information, see [LLMS2006]_ and [LLMSSZ2013]_.
+
+    In Sage, a strong `k`-tableau is created by specifying `k`, a standard strong
+    tableau together with its markings, and a weight `\mu`. Here the standard tableau is
+    represented by a sequence of `k+1`-cores
+
+    .. MATH::
+
+        \lambda^{(0)} \subseteq \lambda^{(1)} \subseteq \cdots \subseteq \lambda^{(m)}
+
+    where each of the `\lambda^{(i)}` is a `k+1`-core.  The standard tableau is a filling
+    of the diagram for the core `\lambda^{(m)}/\lambda^{(0)}` where a strong cover
+    is represented by letters `\pm i` in the skew shape `\lambda^{(i)}/\lambda^{(i-1)}`.
+    Each skew `(k+1)`-core `\lambda^{(i)}/\lambda^{(i-1)}` is a ribbon or multiple
+    copies of the same ribbon which are separated by `k+1` diagonals.  Precisely one of
+    the copies of the ribbons will be marked in the largest diagonal of the connected
+    component (the 'head' of the ribbon).  The marked cells are indicated by negative
+    signs.
+
+    The strong tableau is stored as a standard strong marked tableau (referred to as the
+    standard part of the strong tableau) and a vector representing the weight.
+
+    EXAMPLES::
+
+        sage: StrongTableau( [[-1, -2, -3], [3]], 2, [3] )
+        [[-1, -1, -1], [1]]
+        sage: StrongTableau([[-1,-2,-4,-7],[-3,6,-6,8],[4,7],[-5,-8]], 3, [2,2,3,1])
+        [[-1, -1, -2, -3], [-2, 3, -3, 4], [2, 3], [-3, -4]]
+
+    Alternatively, the strong `k`-tableau can also be entered directly in semistandard
+    format and then the standard tableau and the weight are computed and stored::
+
+        sage: T = StrongTableau([[-1,-1,-1],[1]], 2); T
+        [[-1, -1, -1], [1]]
+        sage: T.to_standard_list()
+        [[-1, -2, -3], [3]]
+        sage: T.weight()
+        (3,)
+        sage: T = StrongTableau([[-1, -1, -2, -3], [-2, 3, -3, 4], [2, 3], [-3, -4]], 3); T
+        [[-1, -1, -2, -3], [-2, 3, -3, 4], [2, 3], [-3, -4]]
+        sage: T.to_standard_list()
+        [[-1, -2, -4, -7], [-3, 6, -6, 8], [4, 7], [-5, -8]]
+        sage: T.weight()
+        (2, 2, 3, 1)
+    """
+
+    def __init__(self, parent, T):
+        """
+        INPUT:
+
+        - ``parent`` -- an instance of ``StrongTableaux``
+        - ``T`` -- standard marked strong (possibly skew) `k`-tableau or a semistandard
+          marked strong (possibly skew) `k`-tableau with inner cells represented by
+          ``None``
+
+        EXAMPLES::
+
+            sage: T = StrongTableau( [[-1, -2, -3]], 3 ); T
+            [[-1, -2, -3]]
+            sage: T
+            [[-1, -2, -3]]
+            sage: T.weight()
+            (1, 1, 1)
+            sage: T.size()
+            3
+            sage: T.parent()
+            Set of strong 3-tableaux of shape [3] and of weight (1, 1, 1)
+            sage: StrongTableau( [[-1, -2, -3], [3]], 2 )
+            [[-1, -2, -3], [3]]
+            sage: StrongTableau( [[-1, -1, 2], [-2]], 2 )
+            [[-1, -1, 2], [-2]]
+            sage: T = StrongTableau( [[-1, -2, 3], [-3]], 2, weight=[2,1] ); T
+            [[-1, -1, 2], [-2]]
+            sage: T = StrongTableau( [[-1, -2, 3], [-3]], 2, weight=[0,2,1] ); T
+            [[-2, -2, 3], [-3]]
+            sage: T.weight()
+            (0, 2, 1)
+            sage: T.size()
+            3
+            sage: T.parent()
+            Set of strong 2-tableaux of shape [3, 1] and of weight (0, 2, 1)
+            sage: StrongTableau( [[-1, -2, 3], [-3]], 2, weight=[1,2] )
+            Traceback (most recent call last):
+            ...
+            ValueError: The weight=(1, 2) and the markings on the standard tableau=[[-1, -2, 3], [-3]] do not agree.
+            sage: StrongTableau( [[None, None, -2, -4], [None, None], [-1, -3], [2, 4], [-5], [5], [5], [5]], 4 )
+            [[None, None, -2, -4], [None, None], [-1, -3], [2, 4], [-5], [5], [5], [5]]
+            sage: StrongTableau( [[None, None, -2, -4], [None, None], [-1, -3], [2, 4], [-5], [5], [5], [5]], 4, weight=[2,2,1] )
+            [[None, None, -1, -2], [None, None], [-1, -2], [1, 2], [-3], [3], [3], [3]]
+            sage: StrongTableau( [[None, None, -1, -2], [None, None], [-1, -2], [1, 2], [-3], [3], [3], [3]], 4)
+            [[None, None, -1, -2], [None, None], [-1, -2], [1, 2], [-3], [3], [3], [3]]
+
+        TESTS::
+
+            sage: T = StrongTableau([], 3); T
+            []
+            sage: T.weight()
+            ()
+            sage: T.parent()
+            Set of strong 3-tableaux of shape [] and of weight ()
+            sage: T = StrongTableau( [[None, None], [None, None]], 4, weight=() ); T
+            [[None, None], [None, None]]
+            sage: T.size()
+            0
+        """
+        self.k = parent.k
+        self._tableau = T
+        ClonableList.__init__(self, parent, T)
+
+    @staticmethod
+    def __classcall_private__(cls, T, k, weight=None):
+        r"""
+        Straighten input and implement the shortcut ``StrongTableau(T, k, weight=None)``
+        to ``StrongTableaux(k, shape, weight)(T)``.
+
+        TESTS::
+
+            sage: t = StrongTableau( [[-1, -2, -3]], 3 )
+            sage: t.parent()
+            Set of strong 3-tableaux of shape [3] and of weight (1, 1, 1)
+            sage: TestSuite(t).run()
+            sage: t = StrongTableau( [[-1, -2, 3], [-3]], 2, weight=[2,1] )
+            sage: TestSuite(t).run()
+            sage: StrongTableau([[-1,-1,-1]], 3)
+            [[-1, -1, -1]]
+            sage: StrongTableau([[None, None, None], [None]], 2)
+            [[None, None, None], [None]]
+
+            sage: StrongTableau([[-1, -2, -2], [1]], 2)
+            Traceback (most recent call last):
+            ...
+            ValueError: Unable to parse strong marked tableau : [[-1, -2, -2], [1]]
+
+            sage: StrongTableau([[-1,-1,-1,-1]], 3)
+            Traceback (most recent call last):
+            ...
+            ValueError: [4] is not a 4-core
+
+            sage: StrongTableau([[-1, -2], [2]], 3)
+            Traceback (most recent call last):
+            ...
+            ValueError: The marks in [[-1, -2], [2]] are not correctly placed.
+
+            sage: StrongTableau([[None, None, None], [None]], 3)
+            Traceback (most recent call last):
+            ...
+            ValueError: [3, 1] is not a 4-core
+
+            sage: StrongTableau([[None, -1, 2], [-2]], 2, [2])
+            Traceback (most recent call last):
+            ...
+            ValueError: The weight=(2,) and the markings on the standard tableau=[[None, -1, 2], [-2]] do not agree.
+        """
+        if isinstance(T, cls):
+            return T
+        outer_shape = Core([len(t) for t in T], k + 1)
+        loop = (row.count(None) for row in T)
+        inner_shape = Core([x for x in loop if x], k + 1)
+        Te = [v for row in T for v in row if v is not None] + [0]
+        count_marks = tuple(Te.count(-(i+1)) for i in range(-min(Te)))
+        if not all(v == 1 for v in count_marks):
+            # if T is not standard -> turn into standard
+            if weight is not None and tuple(weight) != count_marks:
+                raise ValueError("Weight = %s and tableau = %s do not agree" % (weight, T))
+            tijseq = StrongTableaux.marked_CST_to_transposition_sequence(T, k)
+            if tijseq is None or len(tijseq) < sum(list(count_marks)):
+                raise ValueError("Unable to parse strong marked tableau : %s" % T)
+            T = StrongTableaux.transpositions_to_standard_strong( tijseq, k, [[None]*r for r in inner_shape] ) # build from scratch
+            T = T.set_weight( count_marks )
+            return T
+        else:
+            if weight is not None:
+                count_marks = tuple(weight) # in the case that it is standard + weight
+        return StrongTableaux.__classcall__(StrongTableaux, k, (outer_shape, inner_shape), count_marks)(T)
+
+    def check(self):
+        r"""
+        Check that ``self`` is a valid strong `k`-tableau.
+
+        This function verifies that the outer and inner shape of the parent class is equal to
+        the outer and inner shape of the tableau, that the tableau portion of ``self`` is
+        a valid standard tableau, that the marks are placed correctly and that the size
+        and weight agree.
+
+        EXAMPLES::
+
+            sage: T = StrongTableau([[-1, -1, -2], [2]], 2)
+            sage: T.check()
+            sage: T = StrongTableau([[None, None, 2, -4, -4], [-1, 4], [-2]], 3)
+            sage: T.check()
+
+        TESTS::
+
+            sage: ST = StrongTableaux(2, [3,1], [1,1,1,1])
+            sage: ST([[-1,-2,3],[-3]])
+            Traceback (most recent call last):
+            ...
+            ValueError: The size of the tableau [[-1, -2, 3], [-3]] and weight (1, 1, 1, 1) do not match
+            sage: ST([[-1,-3],[-2],[3]])
+            Traceback (most recent call last):
+            ...
+            ValueError: The outer shape of the parent does not agree with the outer shape of the tableau!
+
+            sage: StrongTableau([[-1, -2, 2], [1]], 2)
+            Traceback (most recent call last):
+            ...
+            ValueError: The marks in [[-1, -2, 2], [1]] are not correctly placed.
+
+            sage: StrongTableau([[-1, -2, 3], [3]], 2)
+            Traceback (most recent call last):
+            ...
+            ValueError: The marks in [[-1, -2, 3], [3]] are not correctly placed.
+
+            sage: StrongTableau([[-1,-2,-4,7],[-3,6,-6,8],[4,-7],[-5,-8]], 3, [2,2,3,1])
+            Traceback (most recent call last):
+            ...
+            ValueError: The weight=(2, 2, 3, 1) and the markings on the standard tableau=[[-1, -2, -4, 7], [-3, 6, -6, 8], [4, -7], [-5, -8]] do not agree.
+        """
+        T = SkewTableau(self.to_standard_list())
+        outer = Core(T.outer_shape(),self.k+1)
+        inner = Core(T.inner_shape(),self.k+1)
+        if self.parent()._outer_shape != outer:
+            raise ValueError("The outer shape of the parent does not agree with the outer shape of the tableau!")
+        if self.parent()._inner_shape != inner:
+            raise ValueError("The inner shape of the parent does not agree with the inner shape of the tableau!")
+        if not self._is_valid_marked():
+            raise ValueError("The marks in %s are not correctly placed." % (self.to_standard_list()))
+        if not self._is_valid_standard():
+            raise ValueError("At least one shape in %s is not a valid %s-core." % (self.to_standard_list(), self.k+1))
+        if not self.outer_shape().length()-self.inner_shape().length() == self.size():
+            raise ValueError("The size of the tableau %s and weight %s do not match" % (self.to_standard_list(),self.weight()))
+        if not self.is_column_strict_with_weight( self.weight() ):
+            raise ValueError("The weight=%s and the markings on the standard tableau=%s do not agree." % (self.weight(),self.to_standard_list()))
+
+    def __hash__(self):
+        r"""
+        Return the hash of ``self``.
+
+        EXAMPLES::
+
+            sage: t = StrongTableau([[-1, -1, -2], [2]], 2)
+            sage: hash(t) == hash(t)
+            True
+        """
+        return hash(tuple(tuple(x) for x in self)) + hash(self.parent().k)
+
+    def _is_valid_marked( self ):
+        r"""
+        Check the validity of marks of a potential tableau ``self``.
+
+        This method is called by method :meth:`check` and is not meant to be
+        accessed by the user.
+
+        This method first checks that there is one marked cell for the size of the
+        tableau.  Then, for each marked cell, it verifies that the cell below and to the
+        right is not a positive value.
+
+        In other words this checks that the marked cells are at the head of the connected
+        components.  This function verifies that the markings of ``self`` are
+        consistent with a strong marked standard tableau.
+
+        INPUT:
+
+        - ``self`` -- list of lists representing a potential *standard* marked tableau
+
+        OUTPUT: boolean; ``True`` if the marks are properly placed in the tableau
+
+        EXAMPLES::
+
+            sage: all( T._is_valid_marked() for T in StrongTableaux.standard_marked_iterator(3, 6))
+            True
+            sage: StrongTableau([[-1,-2,-4,-7],[-3,6,-6,8],[4,7],[-5,-8]], 3)._is_valid_marked()
+            True
+            sage: StrongTableau([[-1, -2, 3], [3]], 2)
+            Traceback (most recent call last):
+            ...
+            ValueError: The marks in [[-1, -2, 3], [3]] are not correctly placed.
+
+        Marking in the wrong place::
+
+            sage: StrongTableau([[None, None, -4, 5, -5], [None, None], [-1, -3], [2], [-2], [2], [3]], 4)
+            Traceback (most recent call last):
+            ...
+            ValueError: The marks in [[None, None, -4, 5, -5], [None, None], [-1, -3], [2], [-2], [2], [3]] are not correctly placed.
+
+        No marking on a 2::
+
+            sage: StrongTableau([[None, None, -4, 5, -5], [None, None], [-1, -3], [2], [2], [2], [3]], 4)
+            Traceback (most recent call last):
+            ...
+            ValueError: Unable to parse strong marked tableau : [[None, None, -4, 5, -5], [None, None], [-1, -3], [2], [2], [2], [3]]
+
+        TESTS::
+
+            sage: StrongTableau([[None, None, None], [None]], 2)._is_valid_marked()
+            True
+            sage: StrongTableau([], 4)._is_valid_marked()
+            True
+        """
+        T = self.to_standard_list()
+        size = Core([len(t) for t in T], self.k+1).length()
+        inner_size = Core([y for y in (len([x for x in row if x is None]) for row in T) if y > 0], self.k+1).length()
+        if len(set(v for v in flatten(list(T)) if v in ZZ and v < 0)) != size - inner_size:
+            return False # TT does not have exactly self.size() marked cells
+        for i in range(len(T)):
+            for j in range(len(T[i])):
+                v = T[i][j]
+                if v is not None and v < 0 and ((i != 0 and T[i-1][j] == abs(v)) or (j < len(T[i])-1 and T[i][j+1] == abs(v))):
+                    return False
+        return True
+
+    def _is_valid_standard( self ):
+        r"""
+        Test if ``self`` has a valid strong (un)marked standard part of the tableau.
+
+        This method is called by method :meth:`check` and is not meant to be
+        accessed by the user.
+
+        This methods returns ``True`` if every intermediate shape (restricted to values
+        less than or equal to `i` for each `i`) is a `k+1`-core and that the length
+        of the `i+1`-restricted core is the length of the `i`-restricted core plus 1.
+
+        OUTPUT: boolean; ``True`` means the standard strong marked tableau is valid
+
+        EXAMPLES::
+
+            sage: all( T._is_valid_standard() for T in StrongTableaux.standard_marked_iterator(4, 6))
+            True
+
+        Inner shape is not a 3-core::
+
+            sage: StrongTableau([[None, None, None], [-1]], 2)
+            Traceback (most recent call last):
+            ...
+            ValueError: [3] is not a 3-core
+
+        Restrict to 1 and 2 is not a 5-core::
+
+            sage: StrongTableau([[None, None, -4, 5, -5], [None, None], [-1, -3], [-2], [2], [3], [3]], 4)
+            Traceback (most recent call last):
+            ...
+            ValueError: At least one shape in [[None, None, -4, 5, -5], [None, None], [-1, -3], [-2], [2], [3], [3]] is not a valid 5-core.
+
+        TESTS::
+
+            sage: StrongTableau([[None, None, None], [None]], 2)._is_valid_standard()
+            True
+            sage: StrongTableau([], 4)._is_valid_standard()
+            True
+        """
+        Tshapes = intermediate_shapes(self.to_unmarked_standard_list())
+        if not all(Partition(la).is_core(self.k + 1) for la in Tshapes):
+            return False
+        Tsizes = [Core(lam, self.k + 1).length() for lam in Tshapes]
+        return all(Tsizes[i] == Tsizes[i+1]-1 for i in range(len(Tsizes)-1))
+
+    def is_column_strict_with_weight( self, mu ):
+        """
+        Test if ``self`` is a column strict tableau with respect to the weight ``mu``.
+
+        INPUT:
+
+        - ``mu`` -- a vector of weights
+
+        OUTPUT: boolean; ``True`` means the underlying column strict strong
+        marked tableau is valid
+
+        EXAMPLES::
+
+            sage: StrongTableau([[-1, -2, -3], [3]], 2).is_column_strict_with_weight([3])
+            True
+            sage: StrongTableau([[-1, -2, 3], [-3]], 2).is_column_strict_with_weight([3])
+            False
+
+        TESTS::
+
+            sage: StrongTableau([[None, None, None], [None]], 2).is_column_strict_with_weight([])
+            True
+            sage: StrongTableau([], 4).is_column_strict_with_weight([])
+            True
+        """
+        ss = 0
+        for i in range(len(mu)):
+            for j in range(mu[i]-1):
+                # the markings should move from left to right
+                if self.content_of_marked_head( ss+j+1 ) >= self.content_of_marked_head( ss+j+2 ):
+                    return False
+            ss += mu[i]
+        return True
+
+    def _repr_diagram(self):
+        r"""
+        Return a string representing the pretty print of the tableau.
+
+        EXAMPLES::
+
+            sage: StrongTableau([[-1,-2,-4,-7],[-3,6,-6,8],[4,7],[-5,-8]], 3, [2,2,3,1])._repr_diagram()
+            ' -1 -1 -2 -3\n -2  3 -3  4\n  2  3\n -3 -4'
+            sage: StrongTableau([[None, None, -1, -2], [None, None], [-1, -2], [1, 2], [-3], [3], [3], [3]], 4)._repr_diagram()
+            '  .  . -1 -2\n  .  .\n -1 -2\n  1  2\n -3\n  3\n  3\n  3'
+            sage: StrongTableau([], 4)._repr_diagram()
+            ''
+        """
+        return SkewTableau(self.to_list())._repr_diagram()
+
+    def _repr_list(self):
+        r"""
+        Return a string representing the list of lists of the tableau.
+
+        EXAMPLES::
+
+            sage: StrongTableau([[-1,-2,-4,-7],[-3,6,-6,8],[4,7],[-5,-8]], 3, [2,2,3,1])._repr_list()
+            '[[-1, -1, -2, -3], [-2, 3, -3, 4], [2, 3], [-3, -4]]'
+            sage: StrongTableau([[None, None, -1, -2], [None, None], [-1, -2], [1, 2], [-3], [3], [3], [3]], 4)._repr_list()
+            '[[None, None, -1, -2], [None, None], [-1, -2], [1, 2], [-3], [3], [3], [3]]'
+            sage: StrongTableau([], 4)._repr_list()
+            '[]'
+        """
+        return repr(self.to_list())
+
+    def _repr_compact(self):
+        """
+        Return a compact string representation of ``self``.
+
+        EXAMPLES::
+
+            sage: StrongTableau([[-1,-2,-4,-7],[-3,6,-6,8],[4,7],[-5,-8]], 3, [2,2,3,1])._repr_compact()
+            '-1,-1,-2,-3/-2,3,-3,4/2,3/-3,-4'
+            sage: StrongTableau([[None, None, -1, -2], [None, None], [-1, -2], [1, 2], [-3], [3], [3], [3]], 4)._repr_compact()
+            '.,.,-1,-2/.,./-1,-2/1,2/-3/3/3/3'
+            sage: StrongTableau([],4)._repr_compact()
+            '-'
+        """
+        return SkewTableau(self.to_list())._repr_compact()
+
+    def _repr_(self):
+        r"""
+        Return a representation of ``self``.
+
+        To display a strong marked tableau we display the semistandard version.
+
+        EXAMPLES::
+
+            sage: StrongTableau( [[-1, -2, -3]], 3 )
+            [[-1, -2, -3]]
+            sage: StrongTableau( [[-1, -2, -3]], 3 , weight=[3])
+            [[-1, -1, -1]]
+            sage: StrongTableau( [], 3 )
+            []
+            sage: T = StrongTableau([[-1,-2,3],[-3]],2)
+            sage: T
+            [[-1, -2, 3], [-3]]
+            sage: Tableaux.options(display='diagram')
+            sage: T
+             -1 -2  3
+             -3
+            sage: Tableaux.options(convention='French')
+            sage: T
+             -3
+             -1 -2  3
+            sage: Tableaux.options(display='compact')
+            sage: T
+            -1,-2,3/-3
+            sage: Tableaux.options(display='list',convention='English')
+        """
+        return self.parent().options._dispatch(self, '_repr_', 'display')
+
+    def cell_of_marked_head(self, v):
+        r"""
+        Return location of marked head labeled by ``v`` in the standard part of ``self``.
+
+        Return the coordinates of the ``v``-th marked cell in the strong standard tableau
+        ``self``.  If there is no mark, then the value returned is `(0, r)` where `r` is
+        the length of the first row.
+
+        INPUT:
+
+        - ``v`` -- integer representing the label in the standard tableau
+
+        OUTPUT: a pair of the coordinates of the marked cell with entry ``v``
+
+        EXAMPLES::
+
+            sage: T = StrongTableau([[-1, -3, 4, -5], [-2], [-4]], 3)
+            sage: [ T.cell_of_marked_head(i) for i in range(1,7)]
+            [(0, 0), (1, 0), (0, 1), (2, 0), (0, 3), (0, 4)]
+            sage: T = StrongTableau([[None, None, -1, -2], [None, None], [-1, -2], [1, 2], [-3], [3], [3], [3]], 4)
+            sage: [ T.cell_of_marked_head(i) for i in range(1,7)]
+            [(2, 0), (0, 2), (2, 1), (0, 3), (4, 0), (0, 4)]
+
+        TESTS::
+
+            sage: StrongTableau([],4).cell_of_marked_head(4)
+            (0, 0)
+        """
+        T = self.to_standard_list()
+        if T == []:
+            return (0,0)
+        for i in range(len(T)):
+            for j in range(len(T[i])):
+                if T[i][j] == -v:
+                    return (i,j)
+        return (0,len(T[0]))
+
+    def content_of_marked_head(self, v):
+        r"""
+        Return the diagonal of the marked label ``v`` in the standard part of ``self``.
+
+        Return the content (the `j-i` coordinate of the cell) of the ``v``-th marked cell
+        in the strong standard tableau ``self``.  If there is no mark, then the value
+        returned is the size of first row.
+
+        INPUT:
+
+        - ``v`` -- integer representing the label in the standard tableau
+
+        OUTPUT: integer representing the residue of the location of the mark
+
+        EXAMPLES::
+
+            sage: [ StrongTableau([[-1, -3, 4, -5], [-2], [-4]], 3).content_of_marked_head(i) for i in range(1,7)]
+            [0, -1, 1, -2, 3, 4]
+            sage: T = StrongTableau([[None, None, -1, -2], [None, None], [-1, -2], [1, 2], [-3], [3], [3], [3]], 4)
+            sage: [ T.content_of_marked_head(i) for i in range(1,7)]
+            [-2, 2, -1, 3, -4, 4]
+
+        TESTS::
+
+            sage: StrongTableau([],4).content_of_marked_head(4)
+            0
+        """
+        c = self.cell_of_marked_head(v)
+        return c[1]-c[0]
+
+    def cells_of_marked_ribbon(self, v):
+        r"""
+        Return a list of all cells the marked ribbon labeled by ``v`` in the standard part of ``self``.
+
+        Return the list of coordinates of the cells which are in the marked
+        ribbon with label ``v`` in the standard part of the tableau.  Note that
+        the result is independent of the weight of the tableau.
+
+        The cells are listed from largest content (where the mark is located)
+        to the smallest.  Hence, the first entry in this list will be the marked cell.
+
+        INPUT:
+
+        - ``v`` -- the entry of the standard tableau
+
+        OUTPUT:
+
+        - a list of pairs representing the coordinates of the cells of
+          the marked ribbon
+
+        EXAMPLES::
+
+            sage: T = StrongTableau([[-1, -1, -2, -2, 3], [2, -3], [-3]],3)
+            sage: T.to_standard_list()
+            [[-1, -2, -3, -4, 6], [4, -6], [-5]]
+            sage: T.cells_of_marked_ribbon(1)
+            [(0, 0)]
+            sage: T.cells_of_marked_ribbon(4)
+            [(0, 3)]
+            sage: T = StrongTableau([[-1,-2,-4,-7],[-3,6,-6,8],[4,7],[-5,-8]], 3)
+            sage: T.cells_of_marked_ribbon(6)
+            [(1, 2), (1, 1)]
+            sage: T.cells_of_marked_ribbon(9)
+            []
+            sage: T = StrongTableau([[None, None, -1, -1, 3], [1, -3], [-3]],3)
+            sage: T.to_standard_list()
+            [[None, None, -1, -2, 4], [2, -4], [-3]]
+            sage: T.cells_of_marked_ribbon(1)
+            [(0, 2)]
+
+        TESTS::
+
+            sage: StrongTableau([],3).cells_of_marked_ribbon(1)
+            []
+        """
+        d = self.content_of_marked_head(v)
+        T = SkewTableau(self.to_unmarked_standard_list())
+        cells = []
+        while d is not None:
+            adt = [c for c in T.cells_by_content(d) if T[c[0]][c[1]] == v]
+            if adt == []:
+                d = None
+            else:
+                d -= 1
+                cells += adt
+        return cells
+
+    def cell_of_highest_head( self, v ):
+        """
+        Return the cell of the highest head of label ``v`` in the standard part of ``self``.
+
+        Return the cell where the head of the ribbon in the highest row is located
+        in the underlying standard tableau.  If there is no cell with entry ``v`` then
+        the cell returned is `(0, r)` where `r` is the length of the first row.
+
+        This cell is calculated by iterating through the diagonals of the tableau.
+
+        INPUT:
+
+        - ``v`` -- integer indicating the label in the standard tableau
+
+        OUTPUT: a pair of integers indicating the coordinates of the head of
+        the highest ribbon with label ``v``
+
+        EXAMPLES::
+
+            sage: T = StrongTableau([[-1,2,-3],[-2,3],[3]], 1)
+            sage: [T.cell_of_highest_head(v) for v in range(1,5)]
+            [(0, 0), (1, 0), (2, 0), (0, 3)]
+            sage: T = StrongTableau([[None,None,-3,4],[3,-4]],2)
+            sage: [T.cell_of_highest_head(v) for v in range(1,5)]
+            [(1, 0), (1, 1), (0, 4), (0, 4)]
+
+        TESTS::
+
+            sage: StrongTableau([],2).cell_of_highest_head(1)
+            (0, 0)
+        """
+        Tlist = SkewTableau(self.to_standard_list())
+        if Tlist == []:
+            return (0, 0)
+        r = len(Tlist[0])
+        dout = (0, r)
+        for d in range(-len(Tlist),r+1):
+            for c in Tlist.cells_by_content(d):
+                if nabs(Tlist[c[0]][c[1]]) == v:
+                    dout = c
+            if dout != (0, r) and dout[1]-dout[0] != d:
+                return dout
+        return dout
+
+    def content_of_highest_head( self, v ):
+        r"""
+        Return the diagonal of the highest head of the cells labeled ``v`` in the standard part of ``self``.
+
+        Return the content of the cell of the head in the highest row of all ribbons labeled by ``v`` of
+        the underlying standard tableau.  If there is no cell with entry ``v`` then
+        the value returned is the length of the first row.
+
+        INPUT:
+
+        - ``v`` -- integer representing the label in the standard tableau
+
+        OUTPUT: an integer representing the content of the head of the highest
+        ribbon with label ``v``
+
+        EXAMPLES::
+
+            sage: [StrongTableau([[-1,2,-3],[-2,3],[3]], 1).content_of_highest_head(v) for v in range(1,5)]
+            [0, -1, -2, 3]
+
+        TESTS::
+
+            sage: StrongTableau([], 4).content_of_highest_head(1)
+            0
+            sage: StrongTableau([[-1,-1]], 4).content_of_highest_head(3)
+            2
+        """
+        c = self.cell_of_highest_head(v)
+        return c[1]-c[0]
+
+    def cells_head_dictionary(self):
+        r"""
+        Return a dictionary with the locations of the heads of all markings.
+
+        Return a dictionary of values and lists of cells where the heads with the values
+        are located.
+
+        OUTPUT:
+
+        - a dictionary with keys the entries in the tableau and values are the coordinates
+          of the heads with those entries
+
+        EXAMPLES::
+
+            sage: T = StrongTableau([[-1,-2,-4,7],[-3,6,-6,8],[4,-7],[-5,-8]], 3)
+            sage: T.cells_head_dictionary()
+            {1: [(0, 0)],
+             2: [(0, 1)],
+             3: [(1, 0)],
+             4: [(2, 0), (0, 2)],
+             5: [(3, 0)],
+             6: [(1, 2)],
+             7: [(2, 1), (0, 3)],
+             8: [(3, 1), (1, 3)]}
+            sage: T = StrongTableau([[None, 4, -4, -6, -7, 8, 8, -8], [None, -5, 8, 8, 8], [-3, 6]],3)
+            sage: T.cells_head_dictionary()
+            {1: [(2, 0)],
+             2: [(0, 2)],
+             3: [(1, 1)],
+             4: [(2, 1), (0, 3)],
+             5: [(0, 4)],
+             6: [(1, 4), (0, 7)]}
+             sage: StrongTableau([[None, None], [None, -1]], 4).cells_head_dictionary()
+             {1: [(1, 1)]}
+
+        TESTS::
+
+            sage: StrongTableau([[None, None], [None]], 4).cells_head_dictionary()
+            {}
+            sage: StrongTableau([],4).cells_head_dictionary()
+            {}
+        """
+        return StrongTableaux.cells_head_dictionary(self.to_unmarked_standard_list())
+
+    def cells_of_heads(self, v):
+        r"""
+        Return a list of cells of the heads with label ``v`` in the standard part of ``self``.
+
+        A list of cells which are heads of the ribbons with label ``v`` in the
+        standard part of the tableau ``self``.  If there is no cell labelled by ``v`` then return the empty
+        list.
+
+        INPUT:
+
+        - ``v`` -- integer label
+
+        OUTPUT: a list of pairs of integers of the coordinates of the heads of
+        the ribbons with label ``v``
+
+        EXAMPLES::
+
+            sage: T = StrongTableau([[None, None, -1, -2], [None, None], [-1, -2], [1, 2], [-3], [3], [3], [3]], 4)
+            sage: T.cells_of_heads(1)
+            [(2, 0)]
+            sage: T.cells_of_heads(2)
+            [(3, 0), (0, 2)]
+            sage: T.cells_of_heads(3)
+            [(2, 1)]
+            sage: T.cells_of_heads(4)
+            [(3, 1), (0, 3)]
+            sage: T.cells_of_heads(5)
+            [(4, 0)]
+            sage: T.cells_of_heads(6)
+            []
+
+        TESTS::
+
+            sage: StrongTableau([[None, None], [None]], 4).cells_of_heads(1)
+            []
+            sage: StrongTableau([],4).cells_of_heads(1)
+            []
+        """
+        dout = self.cells_head_dictionary()
+        if v in dout:
+            return dout[v]
+        else:
+            return []
+
+    def contents_of_heads(self, v):
+        r"""
+        A list of contents of the cells which are heads of the ribbons with label ``v``.
+
+        If there is no cell labelled by ``v`` then return the empty list.
+
+        INPUT:
+
+        - ``v`` -- integer label
+
+        OUTPUT: list of integers of the content of the heads of the ribbons
+        with label ``v``
+
+        EXAMPLES::
+
+            sage: T = StrongTableau([[None, None, -1, -2], [None, None], [-1, -2], [1, 2], [-3], [3], [3], [3]], 4)
+            sage: T.contents_of_heads(1)
+            [-2]
+            sage: T.contents_of_heads(2)
+            [-3, 2]
+            sage: T.contents_of_heads(3)
+            [-1]
+            sage: T.contents_of_heads(4)
+            [-2, 3]
+            sage: T.contents_of_heads(5)
+            [-4]
+            sage: T.contents_of_heads(6)
+            []
+
+        TESTS::
+
+            sage: StrongTableau([[None, None], [None]], 4).contents_of_heads(1)
+            []
+            sage: StrongTableau([],4).contents_of_heads(1)
+            []
+        """
+        return [c[1]-c[0] for c in self.cells_of_heads(v)]
+
+    def entries_by_content(self, diag):
+        r"""
+        Return the entries on the diagonal of ``self``.
+
+        Return the entries in the tableau that are in the cells `(i,j)` with
+        `j-i` equal to ``diag`` (that is, with content equal to ``diag``).
+
+        INPUT:
+
+        - ``diag`` -- integer indicating the diagonal
+
+        OUTPUT: list (perhaps empty) of labels on the diagonal ``diag``
+
+        EXAMPLES::
+
+            sage: T = StrongTableau([[None, None, -1, -2], [None, None], [-1, -2], [1, 2], [-3], [3], [3], [3]], 4)
+            sage: T.entries_by_content(0)
+            []
+            sage: T.entries_by_content(1)
+            []
+            sage: T.entries_by_content(2)
+            [-1]
+            sage: T.entries_by_content(-2)
+            [-1, 2]
+
+        TESTS::
+
+            sage: StrongTableau([[None, None], [None]], 4).entries_by_content(1)
+            []
+            sage: StrongTableau([],4).entries_by_content(1)
+            []
+        """
+        return SkewTableau(self.to_list()).entries_by_content(diag)
+
+    def entries_by_content_standard(self, diag):
+        r"""
+        Return the entries on the diagonal of the standard part of ``self``.
+
+        Return the entries in the tableau that are in the cells `(i,j)` with
+        `j-i` equal to ``diag`` (that is, with content equal to ``diag``) in the
+        standard tableau.
+
+        INPUT:
+
+        - ``diag`` -- integer indicating the diagonal
+
+        OUTPUT: list (perhaps empty) of labels on the diagonal ``diag``
+
+        EXAMPLES::
+
+            sage: T = StrongTableau([[None, None, -1, -2], [None, None], [-1, -2], [1, 2], [-3], [3], [3], [3]], 4)
+            sage: T.entries_by_content_standard(0)
+            []
+            sage: T.entries_by_content_standard(1)
+            []
+            sage: T.entries_by_content_standard(2)
+            [-2]
+            sage: T.entries_by_content_standard(-2)
+            [-1, 4]
+
+        TESTS::
+
+            sage: StrongTableau([[None, None], [None]], 4).entries_by_content_standard(1)
+            []
+            sage: StrongTableau([],4).entries_by_content_standard(1)
+            []
+        """
+        return SkewTableau(self.to_standard_list()).entries_by_content(diag)
+
+    def ribbons_above_marked(self, v):
+        r"""
+        Number of ribbons of label ``v`` higher than the marked ribbon in the standard part.
+
+        Return the number of copies of the ribbon with label ``v``  in the standard part
+        of ``self`` which are in a higher row than the marked ribbon.  Note that the result
+        is independent of the weight of the tableau.
+
+        INPUT:
+
+        - ``v`` -- the entry of the standard tableau
+
+        OUTPUT:
+
+        - an integer representing the number of copies of the ribbon above the marked
+          ribbon
+
+        EXAMPLES::
+
+            sage: T = StrongTableau([[-1,-2,-4,-7],[-3,6,-6,8],[4,7],[-5,-8]], 3)
+            sage: T.ribbons_above_marked(4)
+            1
+            sage: T.ribbons_above_marked(6)
+            0
+            sage: T.ribbons_above_marked(9)
+            0
+            sage: StrongTableau([[-1,-2,-3,-4],[2,3,4],[3,4],[4]], 1).ribbons_above_marked(4)
+            3
+
+        TESTS::
+
+            sage: StrongTableau([[None, None], [None]], 4).ribbons_above_marked(1)
+            0
+            sage: StrongTableau([],4).ribbons_above_marked(1)
+            0
+        """
+        d = self.content_of_marked_head(v)
+        count = 0
+        for i in range(self.k+1, len(self.to_standard_list())+d, self.k+1):
+            count += int(v in self.entries_by_content_standard(d-i))
+        return count
+
+    def height_of_ribbon(self, v):
+        r"""
+        The number of rows occupied by one of the ribbons with label ``v``.
+
+        The number of rows occupied by the marked ribbon with label ``v``
+        (and by consequence the number of rows occupied by any ribbon with the same label)
+        in the standard part of ``self``.
+
+        INPUT:
+
+        - ``v`` -- the label of the standard marked tableau
+
+        OUTPUT: nonnegative integer representing the number of rows
+        occupied by the ribbon which is marked
+
+        EXAMPLES::
+
+            sage: T = StrongTableau([[-1, -1, -2, -2, 3], [2, -3], [-3]],3)
+            sage: T.to_standard_list()
+            [[-1, -2, -3, -4, 6], [4, -6], [-5]]
+            sage: T.height_of_ribbon(1)
+            1
+            sage: T.height_of_ribbon(4)
+            1
+            sage: T = StrongTableau([[None,None,1,-2],[None,-3,4,-5],[-1,3],[-4,5]], 3)
+            sage: T.height_of_ribbon(3)
+            2
+            sage: T.height_of_ribbon(6)
+            0
+
+        TESTS::
+
+            sage: StrongTableau([[None, None], [None]], 4).height_of_ribbon(1)
+            0
+            sage: StrongTableau([],4).height_of_ribbon(1)
+            0
+        """
+        return len(set(c[0] for c in self.cells_of_marked_ribbon(v)))
+
+    def number_of_connected_components(self, v):
+        r"""
+        Number of connected components of ribbons with label ``v`` in the standard part.
+
+        The number of connected components is calculated by finding the number of cells
+        with label ``v`` in the standard part of the tableau and dividing by the number
+        of cells in the ribbon.
+
+        INPUT:
+
+        - ``v`` -- the label of the standard marked tableau
+
+        OUTPUT: nonnegative integer representing the number of connected
+        components
+
+        EXAMPLES::
+
+            sage: T = StrongTableau([[-1, -1, -2, -2, 3], [2, -3], [-3]],3)
+            sage: T.to_standard_list()
+            [[-1, -2, -3, -4, 6], [4, -6], [-5]]
+            sage: T.number_of_connected_components(1)
+            1
+            sage: T.number_of_connected_components(4)
+            2
+            sage: T = StrongTableau([[-1,-2,-4,-7],[-3,6,-6,8],[4,7],[-5,-8]], 3)
+            sage: T.number_of_connected_components(6)
+            1
+            sage: T.number_of_connected_components(9)
+            0
+
+        TESTS::
+
+            sage: StrongTableau([[None, None], [None]], 4).number_of_connected_components(1)
+            0
+            sage: StrongTableau([],4).number_of_connected_components(1)
+            0
+        """
+        sz = len(self.cells_of_marked_ribbon(v))
+        if sz == 0:
+            return 0
+        T = self.to_standard_list()
+        nocells = len([i for i in range(len(T)) for j in range(len(T[i])) if T[i][j] == v])+1
+        return ZZ(nocells/sz)
+
+    def intermediate_shapes(self):
+        r"""
+        Return the intermediate shapes of ``self``.
+
+        A (skew) tableau with letters `1, 2, \ldots, \ell` can be viewed as a sequence of
+        shapes, where the `i`-th shape is given by the shape of the subtableau on letters
+        `1, 2, \ldots, i`.
+
+        The output is the list of these shapes.  The marked cells are ignored so to
+        recover the strong tableau one would need the intermediate shapes and the
+        :meth:`content_of_marked_head` for each pair of adjacent shapes in the list.
+
+        OUTPUT: list of lists of integers representing `k+1`-cores
+
+        EXAMPLES::
+
+            sage: T = StrongTableau([[-1,-2,-4,-7],[-3,6,-6,8],[4,7],[-5,-8]], 3, [2,2,3,1])
+            sage: T.intermediate_shapes()
+            [[], [2], [3, 1, 1], [4, 3, 2, 1], [4, 4, 2, 2]]
+            sage: T = StrongTableau([[None, None, -1, -2], [None, None], [-1, -2], [1, 2], [-3], [3], [3], [3]], 4)
+            sage: T.intermediate_shapes()
+            [[2, 2], [3, 2, 1, 1], [4, 2, 2, 2], [4, 2, 2, 2, 1, 1, 1, 1]]
+
+        TESTS::
+
+            sage: StrongTableau([[None, None], [None]], 4).intermediate_shapes()
+            [[2, 1]]
+            sage: StrongTableau([],4).intermediate_shapes()
+            [[]]
+        """
+        return intermediate_shapes(self.to_unmarked_list())
+
+    def pp( self ):
+        r"""
+        Print the strong tableau ``self`` in pretty print format.
+
+        EXAMPLES::
+
+            sage: T = StrongTableau([[-1,-2,-4,-7],[-3,6,-6,8],[4,7],[-5,-8]], 3, [2,2,3,1])
+            sage: T.pp()
+            -1 -1 -2 -3
+            -2  3 -3  4
+             2  3
+            -3 -4
+            sage: T = StrongTableau([[None, None, -1, -2], [None, None], [-1, -2], [1, 2], [-3], [3], [3], [3]], 4)
+            sage: T.pp()
+              .  . -1 -2
+              .  .
+             -1 -2
+              1  2
+             -3
+              3
+              3
+              3
+            sage: Tableaux.options(convention='French')
+            sage: T.pp()
+              3
+              3
+              3
+             -3
+              1  2
+             -1 -2
+              .  .
+              .  . -1 -2
+            sage: Tableaux.options(convention='English')
+        """
+        print(self._repr_diagram())
+
+    def outer_shape( self ):
+        r"""
+        Return the outer shape of ``self``.
+
+        This method returns the outer shape of ``self`` as viewed as a ``Core``.
+        The outer shape of a strong tableau is always a `(k+1)`-core.
+
+        OUTPUT:
+
+        - a `(k+1)`-core
+
+        EXAMPLES::
+
+            sage: StrongTableau([[None, None, -1, -2], [None, None], [-1, -2], [1, 2], [-3], [3], [3], [3]], 4).outer_shape()
+            [4, 2, 2, 2, 1, 1, 1, 1]
+            sage: StrongTableau([[-1,-2,-4,-7],[-3,6,-6,8],[4,7],[-5,-8]], 3, [2,2,3,1]).outer_shape()
+            [4, 4, 2, 2]
+
+        TESTS::
+
+            sage: StrongTableau([[None, None], [None]], 4).outer_shape()
+            [2, 1]
+            sage: StrongTableau([],4).outer_shape()
+            []
+        """
+        return self.parent().outer_shape()
+
+    def inner_shape( self ):
+        r"""
+        Return the inner shape of ``self``.
+
+        If ``self`` is a strong skew tableau, then this method returns the inner shape
+        (the shape of the cells labelled with ``None``).
+        If ``self`` is not skew, then the inner shape is empty.
+
+        OUTPUT:
+
+        - a `(k+1)`-core
+
+        EXAMPLES::
+
+            sage: StrongTableau([[None, None, -1, -2], [None, None], [-1, -2], [1, 2], [-3], [3], [3], [3]], 4).inner_shape()
+            [2, 2]
+            sage: StrongTableau([[-1,-2,-4,-7],[-3,6,-6,8],[4,7],[-5,-8]], 3, [2,2,3,1]).inner_shape()
+            []
+
+        TESTS::
+
+            sage: StrongTableau([[None, None], [None]], 4).inner_shape()
+            [2, 1]
+            sage: StrongTableau([],4).inner_shape()
+            []
+        """
+        return self.parent().inner_shape()
+
+    def shape( self ):
+        r"""
+        Return the shape of ``self``.
+
+        If ``self`` is a skew tableau then return a pair of `k+1`-cores consisting of the
+        outer and the inner shape.  If ``self`` is strong tableau with no inner shape then
+        return a `k+1`-core.
+
+        INPUT:
+
+        - ``form`` -- argument to indicate ``'inner'``, ``'outer'`` or
+          ``'skew'`` (default: ``'outer'``)
+
+        OUTPUT: a `k+1`-core or a pair of `k+1`-cores if form is not
+        ``'inner'`` or ``'outer'``
+
+        EXAMPLES::
+
+            sage: T = StrongTableau([[None, None, -1, -2], [None, None], [-1, -2], [1, 2], [-3], [3], [3], [3]], 4)
+            sage: T.shape()
+            ([4, 2, 2, 2, 1, 1, 1, 1], [2, 2])
+            sage: StrongTableau([[-1, -2, 3], [-3]], 2).shape()
+            [3, 1]
+            sage: type(StrongTableau([[-1, -2, 3], [-3]], 2).shape())
+            <class 'sage.combinat.core.Cores_length_with_category.element_class'>
+
+        TESTS::
+
+            sage: StrongTableau([[None, None, None], [None]], 2).shape()
+            ([3, 1], [3, 1])
+            sage: StrongTableau([],4).shape()
+            []
+        """
+        return self.parent().shape()
+
+    def weight( self ):
+        r"""
+        Return the weight of the tableau.
+
+        The weight is a list of nonnegative integers indicating the number of 1s,
+        number of 2s, number of 3s, etc.
+
+        OUTPUT: list of nonnegative integers
+
+        EXAMPLES::
+
+            sage: T = StrongTableau([[-1, -2, -3, 4], [-4], [-5]], 3); T.weight()
+            (1, 1, 1, 1, 1)
+            sage: T.set_weight([3,1,1]).weight()
+            (3, 1, 1)
+            sage: StrongTableau([[-1,-1,-2,-3],[-2,3,-3,4],[2,3],[-3,-4]], 3).weight()
+            (2, 2, 3, 1)
+
+        TESTS::
+
+            sage: StrongTableau([[None, None], [None]], 4).weight()
+            ()
+            sage: StrongTableau([],4).weight()
+            ()
+        """
+        return self.parent()._weight
+
+    def size( self ):
+        """
+        Return the size of the strong tableau.
+
+        The size of the strong tableau is the sum of the entries in the
+        :meth:`weight`.  It will also be equal to the length of the
+        outer shape (as a `k+1`-core) minus the length of the inner shape.
+
+        .. SEEALSO:: :meth:`sage.combinat.core.Core.length`
+
+        OUTPUT: nonnegative integer
+
+        EXAMPLES::
+
+            sage: StrongTableau([[-1, -2, -3, 4], [-4], [-5]], 3).size()
+            5
+            sage: StrongTableau([[None, None, -1, 2], [-2], [-3]], 3).size()
+            3
+
+        TESTS::
+
+            sage: StrongTableau([[None, None], [None]], 4).size()
+            0
+            sage: StrongTableau([],4).size()
+            0
+        """
+        return sum(self.weight())
+
+    def to_list( self ):
+        """
+        Return the marked column strict (possibly skew) tableau as a list of lists.
+
+        OUTPUT: list of lists of integers or ``None``
+
+        EXAMPLES::
+
+            sage: StrongTableau([[-1, -2, -3, 4], [-4], [-5]], 3).set_weight([2,1,1,1]).to_list()
+            [[-1, -1, -2, 3], [-3], [-4]]
+            sage: StrongTableau([[None, None, -1, -2], [None, None], [-1, -2], [1, 2], [-3], [3], [3], [3]], 4).to_list()
+            [[None, None, -1, -2], [None, None], [-1, -2], [1, 2], [-3], [3], [3], [3]]
+            sage: StrongTableau([[-1, -2, -3, 4], [-4], [-5]], 3, [3,1,1]).to_list()
+            [[-1, -1, -1, 2], [-2], [-3]]
+
+        TESTS::
+
+            sage: StrongTableau([[None, None], [None]], 4).to_list()
+            [[None, None], [None]]
+            sage: StrongTableau([],4).to_list()
+            []
+        """
+        def f(v):
+            # f is a function which maps v or -v to the weight value corresponding to the partition mu
+            if v is None:
+                return None
+            else:
+                return sgn(v)*min([i for i in range(len(self.weight())+1) if sum(self.weight()[:i]) >= abs(v)])
+        return [[f(v) for v in row] for row in self.to_standard_list()]
+
+    def to_unmarked_list( self ):
+        """
+        Return the tableau as a list of lists with markings removed.
+
+        Return the list of lists of the rows of the tableau where the markings have been
+        removed.
+
+        OUTPUT: list of lists of integers or ``None``
+
+        EXAMPLES::
+
+            sage: T = StrongTableau( [[-1, -2, -3, 4], [-4], [-5]], 3, [3,1,1])
+            sage: T.to_unmarked_list()
+            [[1, 1, 1, 2], [2], [3]]
+            sage: TT = T.set_weight([2,1,1,1])
+            sage: TT.to_unmarked_list()
+            [[1, 1, 2, 3], [3], [4]]
+            sage: StrongTableau( [[None, None, -1, -2], [None, None], [-1, -2], [1, 2], [-3], [3], [3], [3]], 4).to_unmarked_list()
+            [[None, None, 1, 2], [None, None], [1, 2], [1, 2], [3], [3], [3], [3]]
+
+        TESTS::
+
+            sage: StrongTableau([[None, None], [None]], 4).to_unmarked_list()
+            [[None, None], [None]]
+            sage: StrongTableau([],4).to_unmarked_list()
+            []
+        """
+        return [[nabs(v) for v in row] for row in self.to_list()]
+
+    def to_standard_list(self):
+        """
+        Return the underlying standard strong tableau as a list of lists.
+
+        Internally, for a strong tableau the standard strong tableau and its weight
+        is stored separately.  This method returns the underlying standard part.
+
+        OUTPUT: list of lists of integers or ``None``
+
+        EXAMPLES::
+
+            sage: StrongTableau([[-1, -2, -3, 4], [-4], [-5]], 3, [3,1,1]).to_standard_list()
+            [[-1, -2, -3, 4], [-4], [-5]]
+            sage: StrongTableau([[None, None, -1, -2], [None, None], [-1, -2], [1, 2], [-3], [3], [3], [3]], 4).to_standard_list()
+            [[None, None, -2, -4], [None, None], [-1, -3], [2, 4], [-5], [5], [5], [5]]
+
+        TESTS::
+
+            sage: StrongTableau([[None, None], [None]], 4).to_standard_list()
+            [[None, None], [None]]
+            sage: StrongTableau([],4).to_standard_list()
+            []
+        """
+        return self._tableau
+
+    def to_standard_tableau(self):
+        """
+        Return the underlying standard strong tableau as a ``StrongTableau`` object.
+
+        Internally, for a strong tableau the standard strong tableau and its weight
+        is stored separately.  This method returns the underlying standard part as a
+        ``StrongTableau``.
+
+        OUTPUT: a strong tableau with standard weight
+
+        EXAMPLES::
+
+            sage: T = StrongTableau([[-1, -2, -3, 4], [-4], [-5]], 3, [3,1,1])
+            sage: T.to_standard_tableau()
+            [[-1, -2, -3, 4], [-4], [-5]]
+            sage: T.to_standard_tableau() == T.to_standard_list()
+            False
+            sage: StrongTableau([[None, None, -1, -2], [None, None], [-1, -2], [1, 2], [-3], [3], [3], [3]], 4).to_standard_tableau()
+            [[None, None, -2, -4], [None, None], [-1, -3], [2, 4], [-5], [5], [5], [5]]
+
+        TESTS::
+
+            sage: StrongTableau([[None, None], [None]], 4).to_standard_tableau()
+            [[None, None], [None]]
+            sage: StrongTableau([],4).to_standard_tableau()
+            []
+        """
+        return StrongTableau(self._tableau, self.k)
+
+    def to_unmarked_standard_list( self ):
+        """
+        Return the standard part of the tableau as a list of lists with markings removed.
+
+        Return the list of lists of the rows of the tableau where the markings have been
+        removed.
+
+        OUTPUT: list of lists of integers or ``None``
+
+        EXAMPLES::
+
+            sage: StrongTableau( [[-1, -2, -3, 4], [-4], [-5]], 3, [3,1,1]).to_unmarked_standard_list()
+            [[1, 2, 3, 4], [4], [5]]
+            sage: StrongTableau( [[None, None, -1, -2], [None, None], [-1, -2], [1, 2], [-3], [3], [3], [3]], 4).to_unmarked_standard_list()
+            [[None, None, 2, 4], [None, None], [1, 3], [2, 4], [5], [5], [5], [5]]
+
+        TESTS::
+
+            sage: StrongTableau([[None, None], [None]], 4).to_unmarked_standard_list()
+            [[None, None], [None]]
+            sage: StrongTableau([],4).to_unmarked_standard_list()
+            []
+        """
+        return [[nabs(l) for l in x] for x in self.to_standard_list()]
+
+    def _latex_(self):
+        r"""
+        Return a latex method for the tableau.
+
+        EXAMPLES::
+
+            sage: T = StrongTableau( [[None, -1, -2, 3], [2, -3]], 2, weight=[2,1] )
+            sage: Tableaux.options(convention = "English")
+            sage: latex(T)
+            {\def\lr#1{\multicolumn{1}{|@{\hspace{.6ex}}c@{\hspace{.6ex}}|}{\raisebox{-.3ex}{$#1$}}}
+            \raisebox{-.6ex}{$\begin{array}[b]{*{4}c}\cline{1-4}
+            \lr{}&\lr{1^\ast}&\lr{1^\ast}&\lr{2}\\\cline{1-4}
+            \lr{1}&\lr{2^\ast}\\\cline{1-2}
+            \end{array}$}
+            }
+            sage: Tableaux.options(convention = "French")
+            sage: latex(T)
+            {\def\lr#1{\multicolumn{1}{|@{\hspace{.6ex}}c@{\hspace{.6ex}}|}{\raisebox{-.3ex}{$#1$}}}
+            \raisebox{-.6ex}{$\begin{array}[t]{*{4}c}\cline{1-2}
+            \lr{1}&\lr{2^\ast}\\\cline{1-4}
+            \lr{}&\lr{1^\ast}&\lr{1^\ast}&\lr{2}\\\cline{1-4}
+            \end{array}$}
+            }
+        """
+        def chi(x):
+            if x is None:
+                return ""
+            if x in ZZ:
+                s = "%s" % abs(x)
+                if x < 0:
+                    s += "^\\ast"
+                return s
+            return "%s" % x
+        T = [[chi(x) for x in row] for row in self.to_list()]
+        from .output import tex_from_array
+        return tex_from_array(T)
+
+    def restrict( self, r ):
+        r"""
+        Restrict the standard part of the tableau to the labels `1, 2, \ldots, r`.
+
+        Return the tableau consisting of the labels of the standard part of ``self``
+        restricted to the labels of `1` through ``r``.  The result is another
+        ``StrongTableau`` object.
+
+        INPUT:
+
+        - ``r`` -- integer
+
+        OUTPUT: a strong tableau
+
+        EXAMPLES::
+
+            sage: T = StrongTableau([[None, None, -4, 5, -5], [None, None], [-1, -3], [-2], [2], [2], [3]], 4, weight=[1,1,1,1,1])
+            sage: T.restrict(3)
+            [[None, None], [None, None], [-1, -3], [-2], [2], [2], [3]]
+            sage: TT = T.restrict(0)
+            sage: TT
+            [[None, None], [None, None]]
+            sage: TT == StrongTableau( [[None, None], [None, None]], 4 )
+            True
+            sage: T.restrict(5) == T
+            True
+
+        TESTS::
+
+            sage: StrongTableau([[None, None], [None]], 4).restrict(1)
+            [[None, None], [None]]
+            sage: StrongTableau([],4).restrict(1)
+            []
+        """
+        rr = sum(self.weight()[:r])
+        rest_tab = [y for y in ([x for x in row if x is None or abs(x) <= rr] for row in self.to_standard_list()) if y]
+        new_parent = StrongTableaux( self.k, (Core([len(x) for x in rest_tab], self.k+1), self.inner_shape()), self.weight()[:r] )
+        return new_parent(rest_tab)
+
+    def set_weight( self, mu ):
+        """
+        Set a new weight ``mu`` for ``self``.
+
+        This method first tests if the underlying standard tableau is column-strict with
+        respect to the weight ``mu``.  If it is, then it changes the weight and returns
+        the tableau; otherwise it raises an error.
+
+        INPUT:
+
+        - ``mu`` -- list of nonnegative integers representing the new weight
+
+        EXAMPLES::
+
+            sage: StrongTableau( [[-1, -2, -3], [3]], 2 ).set_weight( [3] )
+            [[-1, -1, -1], [1]]
+            sage: StrongTableau( [[-1, -2, -3], [3]], 2 ).set_weight( [0,3] )
+            [[-2, -2, -2], [2]]
+            sage: StrongTableau( [[-1, -2, 3], [-3]], 2 ).set_weight( [2, 0, 1] )
+            [[-1, -1, 3], [-3]]
+            sage: StrongTableau( [[-1, -2, 3], [-3]], 2 ).set_weight( [3] )
+            Traceback (most recent call last):
+            ...
+            ValueError: [[-1, -2, 3], [-3]] is not a semistandard strong tableau with respect to the partition [3]
+
+        TESTS::
+
+            sage: StrongTableau([[None, None], [None]], 4).set_weight([])
+            [[None, None], [None]]
+            sage: StrongTableau([],4).set_weight([])
+            []
+        """
+        if sum(mu) != self.size() or self.is_column_strict_with_weight( mu ):
+            return StrongTableaux.__classcall__(StrongTableaux, self.k, (self.outer_shape(), self.inner_shape()), tuple(mu))(self.to_standard_list())
+        else:
+            raise ValueError("%s is not a semistandard strong tableau with respect to the partition %s" % (self, mu))
+
+    def left_action( self, tij ):
+        r"""
+        Action of transposition ``tij`` on ``self`` by adding marked ribbons.
+
+        Computes the left action of the transposition ``tij`` on the tableau.
+        If ``tij`` acting on the element of the affine Grassmannian raises the length by 1,
+        then this function will add a cell to the standard tableau.
+
+        INPUT:
+
+        - ``tij`` -- a transposition represented as a pair `(i, j)`
+
+        OUTPUT: ``self`` after it has been modified by the action of the transposition ``tij``
+
+        EXAMPLES::
+
+            sage: StrongTableau( [[None, -1, -2, -3], [3], [-4]], 3, weight=[1,1,1,1] ).left_action([0,1])
+            [[None, -1, -2, -3, 5], [3, -5], [-4]]
+            sage: StrongTableau( [[None, -1, -2, -3], [3], [-4]], 3, weight=[1,1,1,1] ).left_action([4,5])
+            [[None, -1, -2, -3, -5], [3, 5], [-4]]
+            sage: T = StrongTableau( [[None, -1, -2, -3], [3], [-4]], 3, weight=[1,1,1,1] )
+            sage: T.left_action([-3,-2])
+            [[None, -1, -2, -3], [3], [-4], [-5]]
+            sage: T = StrongTableau( [[None, -1, -2, -3], [3], [-4]], 3, weight=[3,1] )
+            sage: T.left_action([-3,-2])
+            [[None, -1, -1, -1], [1], [-2], [-3]]
+            sage: T
+            [[None, -1, -1, -1], [1], [-2]]
+            sage: T.check()
+            sage: T.weight()
+            (3, 1)
+
+        TESTS::
+
+            sage: StrongTableau([[None, None], [None]], 4).left_action([-2,-1])
+            [[None, None], [None], [-1]]
+            sage: StrongTableau([],4).left_action([0,1])
+            [[-1]]
+        """
+        T = StrongTableaux._left_action_list(copy.deepcopy( self.to_standard_list() ), tij, self.size()+1, self.k)
+        return StrongTableau( T, self.k, self.weight()+(1,) )
+
+    def follows_tableau( self ):
+        r"""
+        Return a list of strong marked tableaux with length one longer than ``self``.
+
+        Return list of all strong tableaux obtained from ``self`` by extending to a core
+        which follows the shape of ``self`` in the strong order.
+
+        OUTPUT: list of strong tableaux which follow ``self`` in strong order
+
+        EXAMPLES::
+
+            sage: T = StrongTableau([[-1,-2,-4,-7],[-3,6,-6,8],[4,7],[-5,-8]], 3, [2,2,3,1])
+            sage: T.follows_tableau()
+            [[[-1, -1, -2, -3, 5, 5, -5], [-2, 3, -3, 4], [2, 3], [-3, -4]],
+             [[-1, -1, -2, -3, 5], [-2, 3, -3, 4], [2, 3, 5], [-3, -4], [-5]],
+             [[-1, -1, -2, -3, 5], [-2, 3, -3, 4], [2, 3, -5], [-3, -4], [5]],
+             [[-1, -1, -2, -3, -5], [-2, 3, -3, 4], [2, 3, 5], [-3, -4], [5]],
+             [[-1, -1, -2, -3], [-2, 3, -3, 4], [2, 3], [-3, -4], [-5], [5], [5]]]
+            sage: StrongTableau([[-1,-2],[-3,-4]],3).follows_tableau()
+            [[[-1, -2, 5, 5, -5], [-3, -4]], [[-1, -2, 5], [-3, -4], [-5]],
+             [[-1, -2, -5], [-3, -4], [5]], [[-1, -2], [-3, -4], [-5], [5], [5]]]
+
+        TESTS::
+
+            sage: StrongTableau([[None, None], [None]], 4).follows_tableau()
+            [[[None, None, -1], [None]], [[None, None], [None, -1]], [[None, None], [None], [-1]]]
+            sage: StrongTableau([],4).follows_tableau()
+            [[[-1]]]
+        """
+        v = self.size()+1
+        out = []
+        for T in StrongTableaux.follows_tableau_unsigned_standard( self.to_standard_list(), self.k ):
+            for m in StrongTableaux.cells_head_dictionary(T)[v]:
+                TT = copy.deepcopy(T)
+                TT[m[0]][m[1]] = -v
+                out.append(StrongTableau(TT, self.k, self.weight()+(1,)))
+        return out
+
+    def spin_of_ribbon( self, v ):
+        r"""
+        Return the spin of the ribbon with label ``v`` in the standard part of ``self``.
+
+        The spin of a ribbon is an integer statistic.  It is the sum of `(h-1) r` plus
+        the number of connected components above the marked one where `h` is the height
+        of the marked ribbon and `r` is the number of connected components.
+
+        .. SEEALSO:: :meth:`height_of_ribbon`, :meth:`number_of_connected_components`,
+          :meth:`ribbons_above_marked`
+
+        INPUT:
+
+        - ``v`` -- a label of the standard part of the tableau
+
+        OUTPUT: integer value representing the spin of the ribbon with label ``v``
+
+        EXAMPLES::
+
+            sage: T = StrongTableau([[-1,-2,5,6],[-3,-4,-7,8],[-5,-6],[7,-8]], 3)
+            sage: [T.spin_of_ribbon(v) for v in range(1,9)]
+            [0, 0, 0, 0, 0, 0, 1, 0]
+            sage: T = StrongTableau([[None,None,-1,-3],[-2,3,-3,4],[2,3],[-3,-4]], 3)
+            sage: [T.spin_of_ribbon(v) for v in range(1,7)]
+            [0, 1, 0, 0, 1, 0]
+
+        TESTS::
+
+            sage: StrongTableau([[None, None], [None]], 4).spin_of_ribbon(1)
+            0
+            sage: StrongTableau([],4).spin_of_ribbon(1)
+            0
+        """
+        return (self.height_of_ribbon(v)-1)*self.number_of_connected_components(v)+self.ribbons_above_marked(v)
+
+    def spin( self ):
+        r"""
+        Return the spin statistic of the tableau ``self``.
+
+        The spin is an integer statistic on a strong marked tableau.  It is
+        the sum of `(h-1) r` plus the number of connected components above the
+        marked one where `h` is the height of the marked ribbon and `r` is
+        the number of connected components.
+
+        .. SEEALSO:: :meth:`height_of_ribbon`, :meth:`number_of_connected_components`,
+          :meth:`ribbons_above_marked`
+
+        The `k`-Schur functions with a parameter `t` can be defined as
+
+        .. MATH::
+
+            s^{(k)}_\lambda[X; t] = \sum_T t^{spin(T)} m_{weight(T)}[X]
+
+        where the sum is over all column strict marked strong `k`-tableaux
+        of shape `\lambda` and partition content.
+
+        OUTPUT: integer value representing the spin
+
+        EXAMPLES::
+
+            sage: StrongTableau([[-1,-2,5,6],[-3,-4,-7,8],[-5,-6],[7,-8]], 3, [2,2,3,1]).spin()
+            1
+            sage: StrongTableau([[-1,-2,-4,-7],[-3,6,-6,8],[4,7],[-5,-8]], 3, [2,2,3,1]).spin()
+            2
+            sage: StrongTableau([[None,None,-1,-3],[-2,3,-3,4],[2,3],[-3,-4]], 3).spin()
+            2
+            sage: ks3 = SymmetricFunctions(QQ['t'].fraction_field()).kschur(3)
+            sage: t = ks3.realization_of().t
+            sage: m = ks3.ambient().realization_of().m()
+            sage: myks221 = sum(sum(t**T.spin() for T in StrongTableaux(3,[3,2,1],weight=mu))*m(mu) for mu in Partitions(5, max_part=3))
+            sage: myks221 == m(ks3[2,2,1])
+            True
+            sage: h = ks3.ambient().realization_of().h()
+            sage: Core([4,4,2,2],4).to_bounded_partition()
+            [2, 2, 2, 2]
+            sage: ks3[2,2,2,2].lift().scalar(h[3,3,2]) == sum( t**T.spin() for T in StrongTableaux(3, [4,4,2,2], weight=[3,3,2]) )
+            True
+
+        TESTS::
+
+            sage: StrongTableau([[None, None], [None]], 4).spin()
+            0
+            sage: StrongTableau([],4).spin()
+            0
+        """
+        return sum(self.spin_of_ribbon(v) for v in range(1,self.size()+1))
+
+    def to_transposition_sequence( self ):
+        """
+        Return a list of transpositions corresponding to ``self``.
+
+        Given a strong column strict tableau ``self`` returns the list of transpositions
+        which when applied to the left of an empty tableau gives the corresponding strong
+        standard tableau.
+
+        OUTPUT: list of pairs of values ``[i,j]`` representing the transpositions `t_{ij}`
+
+        EXAMPLES::
+
+            sage: T = StrongTableau([[-1, -1, -1], [1]],2)
+            sage: T.to_transposition_sequence()
+            [[2, 3], [1, 2], [0, 1]]
+            sage: T = StrongTableau([[-1, -1, 2], [-2]],2)
+            sage: T.to_transposition_sequence()
+            [[-1, 0], [1, 2], [0, 1]]
+            sage: T = StrongTableau([[None, -1, 2, -3], [-2, 3]],2)
+            sage: T.to_transposition_sequence()
+            [[3, 4], [-1, 0], [1, 2]]
+
+        TESTS::
+
+            sage: StrongTableau([[None, None], [None]], 4).to_transposition_sequence()
+            []
+            sage: StrongTableau([],4).to_transposition_sequence()
+            []
+        """
+        return StrongTableaux.marked_CST_to_transposition_sequence( self.to_standard_list(), self.k )
+
+
+class StrongTableaux(UniqueRepresentation, Parent):
+
+    def __init__( self, k, shape, weight ):
+        r"""
+        TESTS::
+
+            sage: strongT = StrongTableaux(2, [3,1], weight=[2,1])
+            sage: TestSuite(strongT).run()
+
+            sage: strongT = StrongTableaux(0, [2,2], weight=[2,2])
+            Traceback (most recent call last):
+            ...
+            ValueError: The input k has to be a positive integer
+        """
+        self._outer_shape = shape[0]
+        self._inner_shape = shape[1]
+        self.k = k
+        if weight is None:
+            self._weight = (1,)*(self._outer_shape.length()-self._inner_shape.length())
+        else:
+            self._weight = weight
+        Parent.__init__(self, category=FiniteEnumeratedSets())
+
+    @staticmethod
+    def __classcall_private__(cls, k, shape, weight=None):
+        r"""
+        Straighten arguments before unique representation.
+
+        TESTS::
+
+            sage: ST3 = StrongTableaux(3, [2,2], weight=[1,1,1,1])
+            sage: TestSuite(ST3).run()
+        """
+        if k <= 0:
+            raise ValueError("The input k has to be a positive integer")
+        if shape == [] or shape[0] in ZZ:
+            outer_shape = Core(shape,k+1)
+            inner_shape = Core([],k+1)
+        else:
+            outer_shape = Core(shape[0],k+1)
+            inner_shape = Core(shape[1],k+1)
+        if weight is not None:
+            weight = tuple(weight)
+        return super().__classcall__(cls, k, (outer_shape, inner_shape), weight)
+
+    def _repr_( self ):
+        r"""
+        Return the representation of ``self``.
+
+        EXAMPLES::
+
+            sage: StrongTableaux(3, [2,2], weight=[1,1,1,1])
+            Set of strong 3-tableaux of shape [2, 2] and of weight (1, 1, 1, 1)
+            sage: StrongTableaux(3, [2,2])
+            Set of strong 3-tableaux of shape [2, 2] and of weight (1, 1, 1, 1)
+            sage: StrongTableaux(3, [[2,2],[1]], weight=[0,0,2,1])
+            Set of strong 3-tableaux of shape [[2, 2], [1]] and of weight (0, 0, 2, 1)
+            sage: StrongTableaux(3, [[],[]], weight=[])
+            Set of strong 3-tableaux of shape [] and of weight ()
+        """
+        if self._inner_shape == Core([],self.k+1):
+            s = "Set of strong %s-tableaux" % self.k
+            s += " of shape %s" % self._outer_shape
+        else:
+            s = "Set of strong %s-tableaux" % self.k
+            s += " of shape [%s, %s]" % (self._outer_shape, self._inner_shape)
+        s += "%sand of weight %s" % (" ",self._weight)
+        return s
+
+    options = Tableaux.options
+
+    def _an_element_(self):
+        r"""
+        Return the first generated element of the class of ``StrongTableaux``.
+
+        EXAMPLES::
+
+            sage: ST = StrongTableaux(3, [3], weight=[3])
+            sage: ST.an_element()
+            [[-1, -1, -1]]
+        """
+        return next(iter(self))
+
+    def outer_shape(self):
+        r"""
+        Return the outer shape of the class of strong tableaux.
+
+        OUTPUT: a `k+1`-core
+
+        EXAMPLES::
+
+            sage: StrongTableaux( 2, [3,1] ).outer_shape()
+            [3, 1]
+            sage: type(StrongTableaux( 2, [3,1] ).outer_shape())
+            <class 'sage.combinat.core.Cores_length_with_category.element_class'>
+            sage: StrongTableaux( 4, [[2,1], [1]] ).outer_shape()
+            [2, 1]
+        """
+        return self._outer_shape
+
+    def inner_shape(self):
+        r"""
+        Return the inner shape of the class of strong tableaux.
+
+        OUTPUT: a `k+1`-core
+
+        EXAMPLES::
+
+            sage: StrongTableaux( 2, [3,1] ).inner_shape()
+            []
+            sage: type(StrongTableaux( 2, [3,1] ).inner_shape())
+            <class 'sage.combinat.core.Cores_length_with_category.element_class'>
+            sage: StrongTableaux( 4, [[2,1], [1]] ).inner_shape()
+            [1]
+        """
+        return self._inner_shape
+
+    def shape(self):
+        r"""
+        Return the shape of ``self``.
+
+        If the ``self`` has an inner shape return a pair consisting of an inner and
+        an outer shape.  If the inner shape is empty then return only the outer shape.
+
+        OUTPUT: a `k+1`-core or a pair of `k+1`-cores
+
+        EXAMPLES::
+
+            sage: StrongTableaux( 2, [3,1] ).shape()
+            [3, 1]
+            sage: type(StrongTableaux( 2, [3,1] ).shape())
+            <class 'sage.combinat.core.Cores_length_with_category.element_class'>
+            sage: StrongTableaux( 4, [[2,1], [1]] ).shape()
+            ([2, 1], [1])
+        """
+        if self._inner_shape:
+            return (self._outer_shape, self._inner_shape)
+        return self._outer_shape
+
+    def __iter__(self):
+        r"""
+        TESTS::
+
+            sage: ST = StrongTableaux(3, [4,1], weight=[2,2])
+            sage: ST.list()
+            [[[-1, -1, -2, -2], [2]], [[-1, -1, 2, -2], [-2]]]
+            sage: ST = StrongTableaux(3, [5,2,2], weight=[2,2,2,1])
+            sage: ST.cardinality()
+            14
+            sage: StrongTableaux(3, [5,2,2], weight=[3,3,1]).list()
+            [[[-1, -1, -1, -2, -2], [-2, 2], [2, -3]], [[-1, -1, -1, 2, -2], [-2, -2], [2, -3]], [[-1, -1, -1, -2, -3], [-2, -2], [2, 2]]]
+            sage: StrongTableaux(3, [4,1,1]).cardinality()
+            10
+            sage: StrongTableaux(3, [5,2,2], weight=[6,1]).list() # there are no strong column strict tableaux of shape [5,2,2] and weight (6,1)
+            []
+            sage: StrongTableaux(3, [[5,2,2], [3,1,1]], weight=[2,1]).list()
+            [[[None, None, None, -1, -1], [None, 1], [None, -2]],
+             [[None, None, None, 1, -1], [None, -1], [None, -2]],
+             [[None, None, None, -1, -2], [None, -1], [None, 1]]]
+            sage: StrongTableaux(2, [[4,3,3,2,2,1,1], [2,1,1]], weight=[1,1,1,1]).cardinality()
+            150
+            sage: StrongTableaux(2, [[7,5,3,1], [2,1,1]], weight=[2,2]).cardinality()
+            18
+            sage: StrongTableaux(2, [[3,1],[3,1]]).list()
+            [[[None, None, None], [None]]]
+            sage: StrongTableaux(4, []).list()
+            [[]]
+        """
+        size = sum(self._weight)
+        if size == 0:
+            yield self([[None]*(row) for row in self._inner_shape])
+        else:
+            for unT in StrongTableaux.standard_unmarked_iterator( self.k, size, self._outer_shape, self._inner_shape ):
+                yield from StrongTableaux.marked_given_unmarked_and_weight_iterator( unT, self.k, self._weight )
+
+    @classmethod
+    def standard_unmarked_iterator( cls, k, size, outer_shape=None, inner_shape=[] ):
+        r"""
+        An iterator for standard unmarked strong tableaux.
+
+        An iterator which generates all unmarked tableaux of a given ``size`` which are
+        contained in ``outer_shape`` and which contain the ``inner_shape``.
+
+        These are built recursively by building all standard marked strong tableaux of
+        size ``size`` `-1` and adding all possible covers.
+
+        If ``outer_shape`` is ``None`` then there is no restriction on the shape of the
+        tableaux which are created.
+
+        INPUT:
+
+        - ``k``, ``size`` -- positive integers
+        - ``outer_shape`` -- list representing a `k+1`-core (default: ``None``)
+        - ``inner_shape`` -- list representing a `k+1`-core (default: ``[]``)
+
+        OUTPUT:
+
+        - an iterator which lists all standard strong unmarked tableaux with ``size``
+          cells and which are contained in ``outer_shape`` and contain ``inner_shape``
+
+        EXAMPLES::
+
+            sage: list(StrongTableaux.standard_unmarked_iterator(2, 3))
+            [[[1, 2, 3], [3]], [[1, 2], [3], [3]], [[1, 3, 3], [2]], [[1, 3], [2], [3]]]
+            sage: list(StrongTableaux.standard_unmarked_iterator(2, 1, inner_shape=[1,1]))
+            [[[None, 1, 1], [None]], [[None, 1], [None], [1]]]
+            sage: len(list(StrongTableaux.standard_unmarked_iterator(4,4)))
+            10
+            sage: len(list(StrongTableaux.standard_unmarked_iterator(4,6)))
+            98
+            sage: len(list(StrongTableaux.standard_unmarked_iterator(4,4, inner_shape=[2,2])))
+            92
+            sage: len(list(StrongTableaux.standard_unmarked_iterator(4,4, outer_shape=[5,2,2,1], inner_shape=[2,2])))
+            10
+
+        TESTS::
+
+            sage: list(StrongTableaux.standard_unmarked_iterator(2,0, outer_shape=[3,1], inner_shape=[3,1]))
+            [[[None, None, None], [None]]]
+            sage: list(StrongTableaux.standard_unmarked_iterator(4,0, outer_shape=[]))
+            [[]]
+        """
+        if size == 0:
+            if outer_shape is None or Core(outer_shape,k+1).contains(inner_shape):
+                yield [[None]*(inner_shape[i]) for i in range(len(inner_shape))]
+        else:
+            for T in cls.standard_unmarked_iterator(k, size-1, outer_shape, inner_shape):
+                for TT in cls.follows_tableau_unsigned_standard(T, k):
+                    if outer_shape is None or Core(outer_shape, k+1).contains([len(r) for r in TT]):
+                        yield TT
+
+    @classmethod
+    def marked_given_unmarked_and_weight_iterator(cls, unmarkedT, k, weight):
+        r"""
+        An iterator generating strong marked tableaux from an unmarked strong tableau.
+
+        Iterator which lists all marked tableaux of weight ``weight`` such that the
+        standard unmarked part of the tableau is equal to ``unmarkedT``.
+
+        INPUT:
+
+        - ``unmarkedT`` -- list of lists representing a strong unmarked tableau
+        - ``k`` -- positive integer
+        - ``weight`` -- list of nonnegative integers indicating the weight
+
+        OUTPUT: an iterator that returns ``StrongTableau`` objects
+
+        EXAMPLES::
+
+            sage: ST = StrongTableaux.marked_given_unmarked_and_weight_iterator([[1,2,3],[3]], 2, [3])
+            sage: list(ST)
+            [[[-1, -1, -1], [1]]]
+            sage: ST = StrongTableaux.marked_given_unmarked_and_weight_iterator([[1,2,3],[3]], 2, [0,3])
+            sage: list(ST)
+            [[[-2, -2, -2], [2]]]
+            sage: ST = StrongTableaux.marked_given_unmarked_and_weight_iterator([[1,2,3],[3]], 2, [1,2])
+            sage: list(ST)
+            [[[-1, -2, -2], [2]]]
+            sage: ST = StrongTableaux.marked_given_unmarked_and_weight_iterator([[1,2,3],[3]], 2, [2,1])
+            sage: list(ST)
+            [[[-1, -1, 2], [-2]], [[-1, -1, -2], [2]]]
+            sage: ST = StrongTableaux.marked_given_unmarked_and_weight_iterator([[None, None, 1, 2, 4], [2, 4], [3]], 3, [3,1])
+            sage: list(ST)
+            []
+            sage: ST = StrongTableaux.marked_given_unmarked_and_weight_iterator([[None, None, 1, 2, 4], [2, 4], [3]], 3, [2,2])
+            sage: list(ST)
+            [[[None, None, -1, -1, 2], [1, -2], [-2]],
+             [[None, None, -1, -1, -2], [1, 2], [-2]]]
+
+        TESTS::
+
+            sage: list(StrongTableaux.marked_given_unmarked_and_weight_iterator([[None, None, None],[None]], 2, []))
+            [[[None, None, None], [None]]]
+            sage: list(StrongTableaux.marked_given_unmarked_and_weight_iterator([], 4, weight=[]))
+            [[]]
+        """
+        td = StrongTableaux.cells_head_dictionary(unmarkedT)
+        if td == {}:  # the tableau is empty
+            yield StrongTableau(unmarkedT, k, [])
+        else:
+            import itertools
+            dsc = Composition(weight).descents()
+            for m in itertools.product(*[td[key] for key in sorted(td)]):
+                if all(((m[i][1]-m[i][0] < m[i+1][1]-m[i+1][0]) or (i in dsc))
+                       for i in range(len(m)-1)):
+                    yield StrongTableaux.add_marking(unmarkedT, m, k, weight)
+
+    @classmethod
+    def add_marking( cls, unmarkedT, marking, k, weight ):
+        r"""
+        Add markings to a partially marked strong tableau.
+
+        Given a partially marked standard tableau and a list of cells where the marks
+        should be placed along with a ``weight``, return the semi-standard marked strong
+        tableau.  The marking should complete the marking so that the result is a
+        strong standard marked tableau.
+
+        INPUT:
+
+        - ``unmarkedT`` -- list of lists which is a partially marked strong `k`-tableau
+        - ``marking`` -- list of pairs of coordinates where cells are to be marked
+        - ``k`` -- positive integer
+        - ``weight`` -- tuple of the weight of the output tableau
+
+        OUTPUT: a ``StrongTableau`` object
+
+        EXAMPLES::
+
+            sage: StrongTableaux.add_marking([[None,1,2],[2]], [(0,1), (1,0)], 2, [1,1])
+            [[None, -1, 2], [-2]]
+            sage: StrongTableaux.add_marking([[None,1,2],[2]], [(0,1), (1,0)], 2, [2])
+            Traceback (most recent call last):
+            ...
+            ValueError: The weight=(2,) and the markings on the standard tableau=[[None, -1, 2], [-2]] do not agree.
+            sage: StrongTableaux.add_marking([[None,1,2],[2]], [(0,1), (0,2)], 2, [2])
+            [[None, -1, -1], [1]]
+
+        TESTS::
+
+            sage: StrongTableaux.add_marking([[None,None,None],[None]], [], 2, [])
+            [[None, None, None], [None]]
+            sage: StrongTableaux.add_marking([], [], 2, [])
+            []
+        """
+        def msgn(c, v):
+            if c in marking:
+                return -v
+            else:
+                return v
+        return StrongTableau([[msgn((i,j),unmarkedT[i][j]) for j in range(len(unmarkedT[i]))] for i in range(len(unmarkedT))], k, weight )
+
+    @classmethod
+    def _left_action_list( cls, Tlist, tij, v, k ):
+        r"""
+        Act by the transposition ``tij`` if it increases the size of the tableau by 1.
+
+        This method modifies the tableau ``Tlist`` instead of returning a copy.
+
+        INPUT:
+
+        - ``Tlist`` -- a partial standard strong `k`-tableau as a list of lists
+        - ``tij`` -- a pair of integers representing a transposition
+        - ``v`` -- the label to add to the tableau
+        - ``k`` -- positive integer
+
+        OUTPUT: list of lists, in particular, it is ``Tlist``
+
+        EXAMPLES::
+
+            sage: StrongTableaux._left_action_list( [[None]], [1,2], 10, 2 )
+            [[None, -10]]
+            sage: StrongTableaux._left_action_list( [[None]], [1,2], 10, 1 )
+            [[None, -10], [10]]
+            sage: StrongTableaux._left_action_list( [[None]], [2,3], 10, 1 )
+            Traceback (most recent call last):
+            ...
+            ValueError: [2, 3] is not a single step up in the strong lattice
+            sage: StrongTableaux._left_action_list( [[None]], [3,4], 10, 1 )
+            [[None, 10], [10]]
+            sage: T = StrongTableaux._left_action_list( [[None]], [1,2], 10, 2 )
+            sage: StrongTableaux._left_action_list( T, [2,3], 4, 2 )
+            [[None, -10, -4], [4]]
+            sage: T
+            [[None, -10, -4], [4]]
+        """
+        innershape = Core([len(r) for r in Tlist], k + 1)
+        outershape = innershape.affine_symmetric_group_action(tij, transposition=True)
+        if outershape.length() == innershape.length() + 1:
+            for c in SkewPartition([outershape.to_partition(),innershape.to_partition()]).cells():
+                while c[0] >= len(Tlist):
+                    Tlist.append([])
+                Tlist[c[0]].append(v)
+                if len(Tlist[c[0]])-c[0] == tij[1]:
+                    Tlist[c[0]][-1] = -Tlist[c[0]][-1]  # mark the cell that is on the j-1 diagonal
+            return Tlist
+
+        raise ValueError("%s is not a single step up in the strong lattice" % tij)
+
+    @classmethod
+    def follows_tableau_unsigned_standard( cls, Tlist, k ):
+        r"""
+        Return a list of strong tableaux one longer in length than ``Tlist``.
+
+        Return list of all standard strong tableaux obtained from ``Tlist`` by extending to
+        a core which follows the shape of ``Tlist`` in the strong order.  It does not put
+        the markings on the last entry that it adds but it does keep the markings on all
+        entries smaller.  The objects returned are not ``StrongTableau`` objects (and
+        cannot be) because the last entry will not properly marked.
+
+        INPUT:
+
+        - ``Tlist`` -- a filling of a `k+1`-core as a list of lists
+        - ``k`` -- integer
+
+        OUTPUT: list of strong tableaux which follow ``Tlist`` in strong order
+
+        EXAMPLES::
+
+            sage: StrongTableaux.follows_tableau_unsigned_standard([[-1, -1, -2, -3], [-2, 3, -3, 4], [2, 3], [-3, -4]], 3)
+            [[[-1, -1, -2, -3, 5, 5, 5], [-2, 3, -3, 4], [2, 3], [-3, -4]],
+             [[-1, -1, -2, -3, 5], [-2, 3, -3, 4], [2, 3, 5], [-3, -4], [5]],
+             [[-1, -1, -2, -3], [-2, 3, -3, 4], [2, 3], [-3, -4], [5], [5], [5]]]
+            sage: StrongTableaux.follows_tableau_unsigned_standard([[None,-1],[-2,-3]],3)
+            [[[None, -1, 4, 4, 4], [-2, -3]], [[None, -1, 4], [-2, -3], [4]],
+             [[None, -1], [-2, -3], [4], [4], [4]]]
+
+        TESTS::
+
+            sage: StrongTableaux.follows_tableau_unsigned_standard([[None, None, None], [None]], 2)
+            [[[None, None, None, 1], [None, 1]], [[None, None, None], [None], [1]]]
+            sage: StrongTableaux.follows_tableau_unsigned_standard([], 4)
+            [[[1]]]
+        """
+        v = 1 + max((abs(v) for rows in Tlist for v in rows if v is not None),
+                    default=0)
+        out = []
+        sh = Core([len(r) for r in Tlist], k + 1)
+        for ga in sh.strong_covers():
+            T = copy.deepcopy(Tlist)
+            T += [[] for _ in repeat(None, len(ga) - len(T))]
+            for c in SkewPartition([ga.to_partition(), sh.to_partition()]).cells():
+                T[c[0]] += [v]
+            out.append(T)
+        return out
+
+    @classmethod
+    def standard_marked_iterator( cls, k, size, outer_shape=None, inner_shape=[] ):
+        r"""
+        An iterator for generating standard strong marked tableaux.
+
+        An iterator which generates all standard marked `k`-tableaux of a given ``size``
+        which are contained in ``outer_shape`` and contain the ``inner_shape``.
+        If ``outer_shape`` is ``None`` then there is no restriction on the shape of the
+        tableaux which are created.
+
+        INPUT:
+
+        - ``k`` -- positive integer
+        - ``size`` -- positive integer
+        - ``outer_shape`` -- list which is a `k+1`-core (default: ``None``)
+        - ``inner_shape`` -- list which is a `k+1`-core (default: ``[]``)
+
+        OUTPUT:
+
+        - an iterator which returns the standard marked tableaux with ``size`` cells
+          and that are contained in ``outer_shape`` and contain ``inner_shape``
+
+        EXAMPLES::
+
+            sage: list(StrongTableaux.standard_marked_iterator(2, 3))
+            [[[-1, -2, 3], [-3]], [[-1, -2, -3], [3]], [[-1, -2], [-3], [3]], [[-1, 3, -3], [-2]], [[-1, 3], [-2], [-3]], [[-1, -3], [-2], [3]]]
+            sage: list(StrongTableaux.standard_marked_iterator(2, 1, inner_shape=[1,1]))
+            [[[None, 1, -1], [None]], [[None, 1], [None], [-1]], [[None, -1], [None], [1]]]
+            sage: len(list(StrongTableaux.standard_marked_iterator(4,4)))
+            10
+            sage: len(list(StrongTableaux.standard_marked_iterator(4,6)))
+            140
+            sage: len(list(StrongTableaux.standard_marked_iterator(4,4, inner_shape=[2,2])))
+            200
+            sage: len(list(StrongTableaux.standard_marked_iterator(4,4, outer_shape=[5,2,2,1], inner_shape=[2,2])))
+            24
+
+        TESTS::
+
+            sage: list(StrongTableaux.standard_marked_iterator(2,0,inner_shape=[3,1]))
+            [[[None, None, None], [None]]]
+            sage: list(StrongTableaux.standard_marked_iterator(4,0))
+            [[]]
+        """
+        for T in cls.standard_unmarked_iterator( k, size, outer_shape, inner_shape ):
+            yield from cls.marked_given_unmarked_and_weight_iterator( T, k, [1]*(size) )
+
+    @classmethod
+    def cells_head_dictionary( cls, T ):
+        r"""
+        Return a dictionary with the locations of the heads of all markings.
+
+        Return a dictionary of values and lists of cells where the heads with the values
+        are located in a strong standard unmarked tableau ``T``.
+
+        INPUT:
+
+        - ``T`` -- a strong standard unmarked tableau as a list of lists
+
+        OUTPUT:
+
+        - a dictionary with keys the entries in the tableau and values are the coordinates
+          of the heads with those entries
+
+        EXAMPLES::
+
+            sage: StrongTableaux.cells_head_dictionary([[1,2,4,7],[3,6,6,8],[4,7],[5,8]])
+            {1: [(0, 0)],
+             2: [(0, 1)],
+             3: [(1, 0)],
+             4: [(2, 0), (0, 2)],
+             5: [(3, 0)],
+             6: [(1, 2)],
+             7: [(2, 1), (0, 3)],
+             8: [(3, 1), (1, 3)]}
+            sage: StrongTableaux.cells_head_dictionary([[None, 2, 2, 4, 5, 6, 6, 6], [None, 3, 6, 6, 6], [1, 4]])
+            {1: [(2, 0)],
+             2: [(0, 2)],
+             3: [(1, 1)],
+             4: [(2, 1), (0, 3)],
+             5: [(0, 4)],
+             6: [(1, 4), (0, 7)]}
+
+        TESTS::
+
+             sage: StrongTableaux.cells_head_dictionary([[None, None, None],[None]])
+             {}
+             sage: StrongTableaux.cells_head_dictionary([])
+             {}
+        """
+        if T == []:
+            return {}
+        ST = SkewTableau(T)
+        dout = {}
+        for i in range(-len(T), len(T[0])):
+            nextv = ST.entries_by_content(i + 1)
+            for c in ST.cells_by_content(i):
+                v = T[c[0]][c[1]]
+                if v not in nextv:
+                    if v in dout:
+                        dout[v] += [c]
+                    else:
+                        dout[v] = [c]
+        return dout
+
+    @classmethod
+    def marked_CST_to_transposition_sequence(self, T, k):
+        """
+        Return a list of transpositions corresponding to ``T``.
+
+        Given a strong column strict tableau ``T`` returns the list of transpositions
+        which when applied to the left of an empty tableau gives the corresponding strong
+        standard tableau.
+
+        INPUT:
+
+        - ``T`` -- a non-empty column strict tableau as a list of lists
+        - ``k`` -- positive integer
+
+        OUTPUT: list of pairs of values ``[i,j]`` representing the transpositions `t_{ij}`
+
+        EXAMPLES::
+
+            sage: CST_to_trans = StrongTableaux.marked_CST_to_transposition_sequence
+            sage: CST_to_trans([[-1, -1, -1], [1]], 2)
+            [[2, 3], [1, 2], [0, 1]]
+            sage: CST_to_trans([], 2)
+            []
+            sage: CST_to_trans([[-2, -2, -2], [2]], 2)
+            [[2, 3], [1, 2], [0, 1]]
+            sage: CST_to_trans([[-1, -2, -2, -2, -2], [-2, 2], [2]], 3)
+            [[4, 5], [3, 4], [2, 3], [1, 2], [-1, 0], [0, 1]]
+            sage: CST_to_trans([[-1, -2, -5, 5, -5, 5, -5], [-3, -4, 5, 5], [5]],3)
+            [[5, 7], [3, 5], [2, 3], [0, 1], [-1, 0], [1, 2], [0, 1]]
+            sage: CST_to_trans([[-1, -2, -3, 4, -7], [-4, -6], [-5, 6]],3)
+            [[4, 5], [-1, 1], [-2, -1], [-1, 0], [2, 3], [1, 2], [0, 1]]
+
+        TESTS::
+
+            sage: StrongTableaux.marked_CST_to_transposition_sequence([[None, None, None], [None]], 2)
+            []
+            sage: StrongTableaux.marked_CST_to_transposition_sequence([], 4)
+            []
+        """
+        LL = list(T)
+        if not LL or all(v is None for v in sum(LL,[])):
+            return []
+        marks = [v for row in T for v in row if v is not None and v < 0] + [0]
+        m = -min(marks) # the largest marked cell
+        transeq = [] # start with the empty list and append on the right
+        sh = Core([len(r) for r in T], k + 1)
+        j = max(c - r for r, row in enumerate(LL) for c, val in enumerate(row)
+                if val == -m)
+        P = sh.to_partition()
+        for l in range(k):
+            msh = sh.affine_symmetric_group_action([j-l,j+1], transposition=True)
+            mP = msh.to_partition()
+            # my worry here is that the affine symmetric group action might apply an invalid
+            # transposition but get something of the right length anyway.  How do I test if it is applying
+            # a valid or invalid transposition?
+            if msh.length() == sh.length() - 1:
+                # if applying t_{j-l,j+1} reduces the size of the shape by 1
+                valcells = [] # values in all the cells except content j
+                regcells = [] # values in the cells with content j
+                valid = True
+                for (x,y) in SkewPartition([P, mP]).cells():
+                    if y-x != j:
+                        if LL[x][y] != m:
+                            valid = False
+                            break
+                        valcells.append(LL[x][y])
+                    else:
+                        regcells.append(LL[x][y])
+                if valid and regcells == [-m]:
+                    # if all labels that are not content j are v and the label
+                    # with content j = -m
+                    mcells = mP.cells()
+                    MM = [[LL[a][b] for b in range(len(LL[a])) if (a,b) in mcells]
+                          for a in range(len(mP))]
+                    transeq = self.marked_CST_to_transposition_sequence(MM, k)
+                    if transeq is not None:
+                        return [[j-l, j+1]] + transeq
+
+    @classmethod
+    def transpositions_to_standard_strong( self, transeq, k, emptyTableau=[] ):
+        """
+        Return a strong tableau corresponding to a sequence of transpositions.
+
+        This method returns the action by left multiplication on the empty strong tableau
+        by transpositions specified by ``transeq``.
+
+        INPUT:
+
+        - ``transeq`` -- a sequence of transpositions `t_{ij}` (a list of pairs)
+        - ``emptyTableau`` -- (default: ``[]``) an empty list or a skew strong tableau
+          possibly consisting of ``None`` entries
+
+        OUTPUT: a ``StrongTableau`` object
+
+        EXAMPLES::
+
+            sage: StrongTableaux.transpositions_to_standard_strong([[0,1]], 2)
+            [[-1]]
+            sage: StrongTableaux.transpositions_to_standard_strong([[-2,-1], [2,3]], 2, [[None, None]])
+            [[None, None, -1], [1], [-2]]
+            sage: StrongTableaux.transpositions_to_standard_strong([[2, 3], [1, 2], [0, 1]], 2)
+            [[-1, -2, -3], [3]]
+            sage: StrongTableaux.transpositions_to_standard_strong([[-1, 0], [1, 2], [0, 1]], 2)
+            [[-1, -2, 3], [-3]]
+            sage: StrongTableaux.transpositions_to_standard_strong([[3, 4], [-1, 0], [1, 2]], 2, [[None]])
+            [[None, -1, 2, -3], [-2, 3]]
+
+        TESTS::
+
+            sage: StrongTableaux.transpositions_to_standard_strong([], 2, [[None, None, None], [None]])
+            [[None, None, None], [None]]
+            sage: StrongTableaux.transpositions_to_standard_strong([], 4, [])
+            []
+        """
+        out = copy.deepcopy(emptyTableau)
+        for i in range(1,len(transeq)+1):
+            out = StrongTableaux._left_action_list(out, transeq[-i], i, k)
+        return StrongTableau(out, k, weight=(1,)*len(transeq))
+
+    Element = StrongTableau
+
+#### common or global functions related to weak/strong tableaux
+
+
+def nabs(v):
+    r"""
+    Return the absolute value of ``v`` or ``None``.
+
+    INPUT:
+
+    - ``v`` -- either an integer or ``None``
+
+    OUTPUT: either a nonnegative integer or ``None``
+
+    EXAMPLES::
+
+        sage: from sage.combinat.k_tableau import nabs
+        sage: nabs(None)
+        sage: nabs(-3)
+        3
+        sage: nabs(None)
+    """
+    if v is None:
+        return v
+    else:
+        return abs(v)
+
+
+def intermediate_shapes(t):
+    r"""
+    Return the intermediate shapes of tableau ``t``.
+
+    A (skew) tableau with letters `1, 2,\ldots, \ell` can be viewed as a sequence of
+    shapes, where the `i`-th shape is given by the shape of the subtableau on letters
+    `1, 2, \ldots, i`.  The output is the list of these shapes.
+
+    OUTPUT: list of lists representing partitions
+
+    EXAMPLES::
+
+        sage: from sage.combinat.k_tableau import intermediate_shapes
+        sage: t = WeakTableau([[1, 1, 2, 2, 3], [2, 3], [3]],3)
+        sage: intermediate_shapes(t)
+        [[], [2], [4, 1], [5, 2, 1]]
+
+        sage: t = WeakTableau([[None, None, 2, 3, 4], [1, 4], [2]], 3)
+        sage: intermediate_shapes(t)
+        [[2], [2, 1], [3, 1, 1], [4, 1, 1], [5, 2, 1]]
+    """
+    shapes = []
+    t = SkewTableau(list(t))
+    for i in range(len(t.weight())+1):
+        shapes += [ t.restrict(i).outer_shape()]
+    return shapes