# 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)[source]#

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

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

affine_symmetric_group_action(w, transposition=False)[source]#

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

INPUT:

• w is a tuple 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]

>>> from sage.all import *
>>> c = Core([Integer(4),Integer(2)],Integer(3))
>>> c.affine_symmetric_group_action([Integer(0),Integer(1),Integer(0),Integer(2),Integer(1)])
[8, 6, 4, 2]
>>> c.affine_symmetric_group_action([Integer(0),Integer(2)], transposition=True)
[4, 2, 1, 1]

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

affine_symmetric_group_simple_action(i)[source]#

Return 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)                             # needs sage.modules
[3, 1]
sage: c.affine_symmetric_group_simple_action(1)                             # needs sage.modules
[5, 3, 1]
sage: c.affine_symmetric_group_simple_action(2)                             # needs sage.modules
[4, 2]

>>> from sage.all import *
>>> c = Core([Integer(4),Integer(2)],Integer(3))
>>> c.affine_symmetric_group_simple_action(Integer(0))                             # needs sage.modules
[3, 1]
>>> c.affine_symmetric_group_simple_action(Integer(1))                             # needs sage.modules
[5, 3, 1]
>>> c.affine_symmetric_group_simple_action(Integer(2))                             # needs sage.modules
[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()                                      # needs sage.modules
sage: i = 0
sage: (c.affine_symmetric_group_simple_action(i).to_grassmannian()          # needs sage.modules
....:     == W.simple_reflection(i)*c.to_grassmannian())
True
sage: i = 1
sage: (c.affine_symmetric_group_simple_action(i).to_grassmannian()          # needs sage.modules
....:     == W.simple_reflection(i)*c.to_grassmannian())
True

>>> from sage.all import *
>>> c = Core([Integer(4),Integer(2)],Integer(3))
>>> W = c.to_grassmannian().parent()                                      # needs sage.modules
>>> i = Integer(0)
>>> (c.affine_symmetric_group_simple_action(i).to_grassmannian()          # needs sage.modules
...     == W.simple_reflection(i)*c.to_grassmannian())
True
>>> i = Integer(1)
>>> (c.affine_symmetric_group_simple_action(i).to_grassmannian()          # needs sage.modules
...     == W.simple_reflection(i)*c.to_grassmannian())
True

contains(other)[source]#

Checks whether self contains other.

INPUT:

• other – another $$k$$-core or a list

OUTPUT: a boolean

This 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

>>> from sage.all import *
>>> c = Core([Integer(4),Integer(2)],Integer(3))
>>> x = Core([Integer(4),Integer(2),Integer(2),Integer(1),Integer(1)],Integer(3))
>>> x.contains(c)
True
>>> c.contains(x)
False

k()[source]#

Return $$k$$ of the $$k$$-core self.

EXAMPLES:

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

>>> from sage.all import *
>>> c = Core([Integer(2),Integer(1)],Integer(4))
>>> c.k()
4

length()[source]#

Return 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()                                          # needs sage.modules
4

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

>>> from sage.all import *
>>> c = Core([Integer(4),Integer(2)],Integer(3)); c.length()
4
>>> c.to_grassmannian().length()                                          # needs sage.modules
4

>>> Core([Integer(9),Integer(5),Integer(3),Integer(2),Integer(1),Integer(1)], Integer(5)).length()
13

size()[source]#

Return the size of self as a partition.

EXAMPLES:

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

>>> from sage.all import *
>>> Core([Integer(2),Integer(1)],Integer(4)).size()
3
>>> Core([Integer(4),Integer(2)],Integer(3)).size()
6

strong_covers()[source]#

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

>>> from sage.all import *
>>> c = Core([Integer(1)],Integer(3))
>>> c.strong_covers()
[[2], [1, 1]]
>>> c = Core([Integer(4),Integer(2)],Integer(3))
>>> c.strong_covers()
[[5, 3, 1], [4, 2, 1, 1]]

strong_down_list()[source]#

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

>>> from sage.all import *
>>> c = Core([Integer(1)],Integer(3))
>>> c.strong_down_list()
[[]]
>>> c = Core([Integer(5),Integer(3),Integer(1)],Integer(3))
>>> c.strong_down_list()
[[4, 2], [3, 1, 1]]

strong_le(other)[source]#

Strong order (Bruhat) comparison on cores.

INPUT:

• other – another $$k$$-core

OUTPUT: a boolean

This 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

>>> from sage.all import *
>>> c = Core([Integer(4),Integer(2)],Integer(3))
>>> x = Core([Integer(4),Integer(2),Integer(2),Integer(1),Integer(1)],Integer(3))
>>> c.strong_le(x)
True
>>> c.strong_le([Integer(4),Integer(2),Integer(2),Integer(1),Integer(1)])
True

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

to_bounded_partition()[source]#

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

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

>>> from sage.all import *
>>> gamma = Core([Integer(9),Integer(5),Integer(3),Integer(2),Integer(1),Integer(1)], Integer(5))
>>> gamma.to_bounded_partition()
[4, 3, 2, 2, 1, 1]

to_grassmannian()[source]#

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                                            # needs sage.modules
[-1  1  1]
[-2  2  1]
[-2  1  2]
sage: c.parent()
3-Cores of length 4
sage: w.parent()                                                            # needs sage.modules
Weyl Group of type ['A', 2, 1] (as a matrix group acting on the root space)

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

>>> from sage.all import *
>>> c = Core([Integer(3),Integer(1),Integer(1)],Integer(3))
>>> w = c.to_grassmannian(); w                                            # needs sage.modules
[-1  1  1]
[-2  2  1]
[-2  1  2]
>>> c.parent()
3-Cores of length 4
>>> w.parent()                                                            # needs sage.modules
Weyl Group of type ['A', 2, 1] (as a matrix group acting on the root space)

>>> c = Core([],Integer(3))
>>> c.to_grassmannian()                                                   # needs sage.modules
[1 0 0]
[0 1 0]
[0 0 1]

to_partition()[source]#

Turn the core self into the partition identical to self.

EXAMPLES:

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

>>> from sage.all import *
>>> mu = Core([Integer(2),Integer(1),Integer(1)],Integer(3))
>>> mu.to_partition()
[2, 1, 1]

weak_covers()[source]#

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

EXAMPLES:

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

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

>>> from sage.all import *
>>> c = Core([Integer(1)],Integer(3))
>>> c.weak_covers()                                                       # needs sage.modules
[[1, 1], [2]]

>>> c = Core([Integer(4),Integer(2)],Integer(3))
>>> c.weak_covers()                                                       # needs sage.modules
[[5, 3, 1]]

weak_le(other)[source]#

Weak order comparison on cores.

INPUT:

• other – another $$k$$-core

OUTPUT: a boolean

This 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)                                                          # needs sage.modules
True
sage: c.weak_le([5,3,1])                                                    # needs sage.modules
True

sage: x = Core([4,2,2,1,1],3)
sage: c.weak_le(x)                                                          # needs sage.modules
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

>>> from sage.all import *
>>> c = Core([Integer(4),Integer(2)],Integer(3))
>>> x = Core([Integer(5),Integer(3),Integer(1)],Integer(3))
>>> c.weak_le(x)                                                          # needs sage.modules
True
>>> c.weak_le([Integer(5),Integer(3),Integer(1)])                                                    # needs sage.modules
True

>>> x = Core([Integer(4),Integer(2),Integer(2),Integer(1),Integer(1)],Integer(3))
>>> c.weak_le(x)                                                          # needs sage.modules
False

>>> x = Core([Integer(5),Integer(3),Integer(1)],Integer(6))
>>> 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)[source]#

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]

>>> from sage.all import *
>>> C = Cores(Integer(4), Integer(6)); C
4-Cores of length 6
>>> 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]]
>>> C.cardinality()
7
>>> 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]

>>> from sage.all import *
>>> C = Cores(Integer(4), size=Integer(6)); C
4-Cores of size 6
>>> C.list()
[[4, 1, 1], [3, 2, 1], [3, 1, 1, 1]]
>>> C.cardinality()
3
>>> C.an_element()
[4, 1, 1]

class sage.combinat.core.Cores_length(k, n)[source]#

The class of $$k$$-cores of length $$n$$.

Element[source]#

alias of Core

from_partition(part)[source]#

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

>>> from sage.all import *
>>> C = Cores(Integer(3),Integer(4))
>>> c = C.from_partition([Integer(4),Integer(2)]); c
[4, 2]

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

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

list()[source]#

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

>>> from sage.all import *
>>> C = Cores(Integer(3),Integer(4))
>>> C.list()
[[4, 2], [3, 1, 1], [2, 2, 1, 1]]

class sage.combinat.core.Cores_size(k, n)[source]#

The class of $$k$$-cores of size $$n$$.

Element[source]#

alias of Core

from_partition(part)[source]#

Convert 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

>>> from sage.all import *
>>> C = Cores(Integer(3),size=Integer(4))
>>> c = C.from_partition([Integer(2),Integer(1),Integer(1)]); c
[2, 1, 1]

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

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

list()[source]#

Return the list of all $$k$$-cores of size $$n$$.

EXAMPLES:

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

>>> from sage.all import *
>>> C = Cores(Integer(3), size = Integer(4))
>>> C.list()
[[3, 1], [2, 1, 1]]