### Navigation

- index
- modules |
- next |
- previous |
- Combinatorics »

# Cores

A \(k\)-core is a partition from which no rim hook of size \(k\) can be removed. Alternatively, a \(k\)-core is an integer partition such that the Ferrers diagram for the partition contains no cells with a hook of size (a multiple of) \(k\).

Authors:

- Anne Schilling and Mike Zabrocki (2011): initial version
- Travis Scrimshaw (2012): Added latex output for Core class

class `sage.combinat.core.``Core`(parent, core)

  Bases: `sage.combinat.combinat.CombinatorialObject`, `sage.structure.element.Element`

  A \(k\)-core is an integer partition from which no rim hook of size \(k\) can be removed.

  EXAMPLES:

      sage: c = Core([2,1],4); c
      [2, 1]
      sage: c = Core([3,1],4); c
      Traceback (most recent call last):
      ...
      ValueError: [3, 1] is not a 4-core

  `affine_symmetric_group_action`(w, transposition=False)

    Returns the (left) action of the affine symmetric group on `self`.

    INPUT:

    - `w` is a tupe of integers \([w_1,\ldots,w_m]\) with \(0\le w_j<k\). If transposition is set to be True, then \(w = [w_0,w_1]\) is interpreted as a transposition \(t_{w_0, w_1}\) (see `_transposition_to_reduced_word()`).

    The output is the (left) action of the product of the corresponding simple transpositions on `self`, that is \(s_{w_1} \cdots s_{w_m}(self)\). See `affine_symmetric_group_simple_action()`.

    EXAMPLES:

        sage: c = Core([4,2],3)
        sage: c.affine_symmetric_group_action([0,1,0,2,1])
        [8, 6, 4, 2]
        sage: c.affine_symmetric_group_action([0,2], transposition=True)
        [4, 2, 1, 1]

        sage: c = Core([11,8,5,5,3,3,1,1,1],4)
        sage: c.affine_symmetric_group_action([2,5],transposition=True)
        [11, 8, 7, 6, 5, 4, 3, 2, 1]

  `affine_symmetric_group_simple_action`(i)

    Returns the action of the simple transposition \(s_i\) of the affine symmetric group on `self`.

    This gives the action of the affine symmetric group of type \(A_k^{(1)}\) on the \(k\)-core `self`. If `self` has outside (resp. inside) corners of content \(i\) modulo \(k\), then these corners are added (resp. removed). Otherwise the action is trivial.

    EXAMPLES:

        sage: c = Core([4,2],3)
        sage: c.affine_symmetric_group_simple_action(0)
        [3, 1]
        sage: c.affine_symmetric_group_simple_action(1)
        [5, 3, 1]
        sage: c.affine_symmetric_group_simple_action(2)
        [4, 2]

    This action corresponds to the left action by the \(i\)-th simple reflection in the affine symmetric group:

        sage: c = Core([4,2],3)
        sage: W = c.to_grassmannian().parent()
        sage: i=0
        sage: c.affine_symmetric_group_simple_action(i).to_grassmannian() == W.simple_reflection(i)*c.to_grassmannian()
        True
        sage: i=1
        sage: c.affine_symmetric_group_simple_action(i).to_grassmannian() == W.simple_reflection(i)*c.to_grassmannian()
        True

  `contains`(other)

    Checks whether `self` contains `other`.

    INPUT:

    - `other` – another \(k\)-core or a list

    OUTPUT: a boolean

    Returns `True` if the Ferrers diagram of `self` contains the Ferrers diagram of other.

    EXAMPLES:

        sage: c = Core([4,2],3)
        sage: x = Core([4,2,2,1,1],3)
        sage: x.contains(c)
        True
        sage: c.contains(x)
        False

  `k`()

    Returns \(k\) of the \(k\)-core `self`.

    EXAMPLES:

        sage: c = Core([2,1],4)
        sage: c.k()
        4

  `length`()

    Returns the length of `self`.

    The length of a \(k\)-core is the size of the corresponding \((k-1)\)-bounded partition which agrees with the length of the corresponding Grassmannian element, see `to_grassmannian()`.

    EXAMPLES:

        sage: c = Core([4,2],3); c.length()
        4
        sage: c.to_grassmannian().length()
        4

        sage: Core([9,5,3,2,1,1], 5).length()
        13

  `size`()

    Returns the size of `self` as a partition.

    EXAMPLES:

        sage: Core([2,1],4).size()
        3
        sage: Core([4,2],3).size()
        6

  `strong_covers`()

    Returns a list of all elements that cover `self` in strong order.

    EXAMPLES:

        sage: c = Core([1],3)
        sage: c.strong_covers()
        [[2], [1, 1]]
        sage: c = Core([4,2],3)
        sage: c.strong_covers()
        [[5, 3, 1], [4, 2, 1, 1]]

  `strong_down_list`()

    Returns a list of all elements that are covered by `self` in strong order.

    EXAMPLES:

        sage: c = Core([1],3)
        sage: c.strong_down_list()
        [[]]
        sage: c = Core([5,3,1],3)
        sage: c.strong_down_list()
        [[4, 2], [3, 1, 1]]

  `strong_le`(other)

    Strong order (Bruhat) comparison on cores.

    INPUT:

    - `other` – another \(k\)-core

    OUTPUT: a boolean

    Returns whether `self` <= `other` in Bruhat (or strong) order.

    EXAMPLES:

        sage: c = Core([4,2],3)
        sage: x = Core([4,2,2,1,1],3)
        sage: c.strong_le(x)
        True
        sage: c.strong_le([4,2,2,1,1])
        True

        sage: x = Core([4,1],4)
        sage: c.strong_le(x)
        Traceback (most recent call last):
        ...
        ValueError: The two cores do not have the same k

  `to_bounded_partition`()

    Bijection between \(k\)-cores and \((k-1)\)-bounded partitions.

    Maps the \(k\)-core `self` to the corresponding \((k-1)\)-bounded partition. This bijection is achieved by deleting all cells in `self` of hook length greater than \(k\).

    EXAMPLES:

        sage: gamma = Core([9,5,3,2,1,1], 5)
        sage: gamma.to_bounded_partition()
        [4, 3, 2, 2, 1, 1]

  `to_grassmannian`()

    Bijection between \(k\)-cores and Grassmannian elements in the affine Weyl group of type \(A_{k-1}^{(1)}\).

    For further details, see the documentation of the method `from_kbounded_to_reduced_word()` and `from_kbounded_to_grassmannian()`.

    EXAMPLES:

        sage: c = Core([3,1,1],3)
        sage: w = c.to_grassmannian(); w
        [-1  1  1]
        [-2  2  1]
        [-2  1  2]
        sage: c.parent()
        3-Cores of length 4
        sage: w.parent()
        Weyl Group of type ['A', 2, 1] (as a matrix group acting on the root space)

        sage: c = Core([],3)
        sage: c.to_grassmannian()
        [1 0 0]
        [0 1 0]
        [0 0 1]

  `to_partition`()

    Turns the core `self` into the partition identical to `self`.

    EXAMPLES:

        sage: mu = Core([2,1,1],3)
        sage: mu.to_partition()
        [2, 1, 1]

  `weak_covers`()

    Returns a list of all elements that cover `self` in weak order.

    EXAMPLES:

        sage: c = Core([1],3)
        sage: c.weak_covers()
        [[2], [1, 1]]

        sage: c = Core([4,2],3)
        sage: c.weak_covers()
        [[5, 3, 1]]

  `weak_le`(other)

    Weak order comparison on cores.

    INPUT:

    - `other` – another \(k\)-core

    OUTPUT: a boolean

    Returns whether `self` <= `other` in weak order.

    EXAMPLES:

        sage: c = Core([4,2],3)
        sage: x = Core([5,3,1],3)
        sage: c.weak_le(x)
        True
        sage: c.weak_le([5,3,1])
        True

        sage: x = Core([4,2,2,1,1],3)
        sage: c.weak_le(x)
        False

        sage: x = Core([5,3,1],6)
        sage: c.weak_le(x)
        Traceback (most recent call last):
        ...
        ValueError: The two cores do not have the same k

`sage.combinat.core.``Cores`(k, length=None, **kwargs)

  A \(k\)-core is a partition from which no rim hook of size \(k\) can be removed. Alternatively, a \(k\)-core is an integer partition such that the Ferrers diagram for the partition contains no cells with a hook of size (a multiple of) \(k\).

  The \(k\)-cores generally have two notions of size which are useful for different applications. One is the number of cells in the Ferrers diagram with hook less than \(k\), the other is the total number of cells of the Ferrers diagram. In the implementation in Sage, the first of notion is referred to as the `length` of the \(k\)-core and the second is the `size` of the \(k\)-core. The class of Cores requires that either the size or the length of the elements in the class is specified.

  EXAMPLES:

  We create the set of the \(4\)-cores of length \(6\). Here the length of a \(k\)-core is the size of the corresponding \((k-1)\)-bounded partition, see also `length()`:

      sage: C = Cores(4, 6); C
      4-Cores of length 6
      sage: C.list()
      [[6, 3], [5, 2, 1], [4, 1, 1, 1], [4, 2, 2], [3, 3, 1, 1], [3, 2, 1, 1, 1], [2, 2, 2, 1, 1, 1]]
      sage: C.cardinality()
      7
      sage: C.an_element()
      [6, 3]

  We may also list the set of \(4\)-cores of size \(6\), where the size is the number of boxes in the core, see also `size()`:

      sage: C = Cores(4, size=6); C
      4-Cores of size 6
      sage: C.list()
      [[4, 1, 1], [3, 2, 1], [3, 1, 1, 1]]
      sage: C.cardinality()
      3
      sage: C.an_element()
      [4, 1, 1]

class `sage.combinat.core.``Cores_length`(k, n)

  Bases: `sage.structure.unique_representation.UniqueRepresentation`, `sage.structure.parent.Parent`

  The class of \(k\)-cores of length \(n\).

  `Element`

    alias of `Core`

  `from_partition`(part)

    Converts the partition `part` into a core (as the identity map).

    This is the inverse method to `to_partition()`.

    EXAMPLES:

        sage: C = Cores(3,4)
        sage: c = C.from_partition([4,2]); c
        [4, 2]

        sage: mu = Partition([2,1,1])
        sage: C = Cores(3,3)
        sage: C.from_partition(mu).to_partition() == mu
        True

        sage: mu = Partition([])
        sage: C = Cores(3,0)
        sage: C.from_partition(mu).to_partition() == mu
        True

  `list`()

    Returns the list of all \(k\)-cores of length \(n\).

    EXAMPLES:

        sage: C = Cores(3,4)
        sage: C.list()
        [[4, 2], [3, 1, 1], [2, 2, 1, 1]]

class `sage.combinat.core.``Cores_size`(k, n)

  Bases: `sage.structure.unique_representation.UniqueRepresentation`, `sage.structure.parent.Parent`

  The class of \(k\)-cores of size \(n\).

  `Element`

    alias of `Core`

  `from_partition`(part)

    Converts the partition `part` into a core (as the identity map).

    This is the inverse method to `to_partition()`.

    EXAMPLES:

        sage: C = Cores(3,size=4)
        sage: c = C.from_partition([2,1,1]); c
        [2, 1, 1]

        sage: mu = Partition([2,1,1])
        sage: C = Cores(3,size=4)
        sage: C.from_partition(mu).to_partition() == mu
        True

        sage: mu = Partition([])
        sage: C = Cores(3,size=0)
        sage: C.from_partition(mu).to_partition() == mu
        True

  `list`()

    Returns the list of all \(k\)-cores of size \(n\).

    EXAMPLES:

        sage: C = Cores(3, size = 4)
        sage: C.list()
        [[3, 1], [2, 1, 1]]

### Navigation

- index
- modules |
- next |
- previous |
- Combinatorics »