Skew Partitions

A skew partition skp of size n is a pair of partitions [p_1, p_2] where p_1 is a partition of the integer n_1, p_2 is a partition of the integer n_2, p_2 is an inner partition of p_1, and n = n_1 - n_2. We say that p_1 and p_2 are respectively the inner and outer partitions of skp.

A skew partition can be depicted by a diagram made of rows of boxes, in the same way as a partition. Only the boxes of the outer partition p_1 which are not in the inner partition p_2 appear in the picture. For example, this is the diagram of the skew partition [[5,4,3,1],[3,3,1]].

sage: print SkewPartition([[5,4,3,1],[3,3,1]]).diagram()
   ##
   #
 ##
#

A skew partition can be connected, which can easily be described in graphic terms: for each pair of consecutive rows, there are at least two boxes (one in each row) which have a common edge. This is the diagram of the connected skew partition [[5,4,3,1],[3,1]]:

sage: print SkewPartition([[5,4,3,1],[3,1]]).diagram()
   ##
 ###
###
#
sage: SkewPartition([[5,4,3,1],[3,1]]).is_connected()
True

The first example of a skew partition is not a connected one.

Applying a reflection with respect to the main diagonal yields the diagram of the conjugate skew partition, here [[4,3,3,2,1],[3,3,2]]:

sage: SkewPartition([[5,4,3,1],[3,3,1]]).conjugate()
[[4, 3, 3, 2, 1], [3, 2, 2]]
sage: print SkewPartition([[5,4,3,1],[3,3,1]]).conjugate().diagram()
   #
  #
  #
##
#

The outer corners of a skew partition are the corners of its outer partition. The inner corners are the internal corners of the outer partition when the inner partition is taken off. Shown below are the coordinates of the inner and outer corners.

sage: SkewPartition([[5,4,3,1],[3,3,1]]).outer_corners()
[[0, 4], [1, 3], [2, 2], [3, 0]]
sage: SkewPartition([[5,4,3,1],[3,3,1]]).inner_corners()
[[0, 3], [2, 1], [3, 0]]

EXAMPLES: There are 9 skew partitions of size 3.

sage: SkewPartitions(3).cardinality()
9
sage: SkewPartitions(3).list()
[[[1, 1, 1], []],
 [[2, 2, 1], [1, 1]],
 [[2, 1, 1], [1]],
 [[3, 2, 1], [2, 1]],
 [[2, 2], [1]],
 [[3, 2], [2]],
 [[2, 1], []],
 [[3, 1], [1]],
 [[3], []]]

There are 4 connected skew partitions of size 3.

sage: SkewPartitions(3, overlap=1).cardinality()
4
sage: SkewPartitions(3, overlap=1).list()
[[[1, 1, 1], []], [[2, 2], [1]], [[2, 1], []], [[3], []]]

This is the conjugate of the skew partition [[4,3,1],[2]]

sage: SkewPartition([[4,3,1],[2]]).conjugate()
[[3, 2, 2, 1], [1, 1]]

Geometrically, we just applied a reflection with respect to the main diagonal on the diagram of the partition. Of course, this operation is an involution:

sage: SkewPartition([[4,3,1],[2]]).conjugate().conjugate()
[[4, 3, 1], [2]]

The jacobi_trudy() method computes the Jacobi-Trudi matrix. See Macdonald I.-G., (1995), “Symmetric Functions and Hall Polynomials”, Oxford Science Publication for a definition and discussion.

sage: SkewPartition([[4,3,1],[2]]).jacobi_trudi()
[h[2]  h[]    0]
[h[5] h[3]  h[]]
[h[6] h[4] h[1]]

This example shows how to compute the corners of a skew partition.

sage: SkewPartition([[4,3,1],[2]]).inner_corners()
[[0, 2], [1, 0]]
sage: SkewPartition([[4,3,1],[2]]).outer_corners()    
[[0, 3], [1, 2], [2, 0]]
sage.combinat.skew_partition.SkewPartition(skp)

Returns the skew partition object corresponding to skp.

EXAMPLES:

sage: skp = SkewPartition([[3,2,1],[2,1]]); skp
[[3, 2, 1], [2, 1]]
sage: skp.inner()
[2, 1]
sage: skp.outer()
[3, 2, 1]
class sage.combinat.skew_partition.SkewPartition_class(skp)
__init__(skp)

TESTS:

sage: skp = SkewPartition([[3,2,1],[2,1]])
sage: skp == loads(dumps(skp))
True
column_lengths()

Returns the column lengths of the skew partition.

EXAMPLES:

sage: SkewPartition([[3,2,1],[1,1]]).column_lengths()
[1, 2, 1]
sage: SkewPartition([[5,2,2,2],[2,1]]).column_lengths()
[2, 3, 1, 1, 1]
columns_intersection_set()

Returns the set of boxes in the lines of lambda which intersect the skew partition.

EXAMPLES:

sage: skp = SkewPartition([[3,2,1],[2,1]])
sage: boxes = Set([ (0,0), (0, 1), (0,2), (1, 0), (1, 1), (2, 0)])
sage: skp.columns_intersection_set() == boxes
True
conjugate()

Returns the conjugate of the skew partition skp.

EXAMPLES:

sage: SkewPartition([[3,2,1],[2]]).conjugate()
[[3, 2, 1], [1, 1]]
diagram()

Return the Ferrers diagram of self.

EXAMPLES:

sage: print SkewPartition([[5,4,3,1],[3,3,1]]).ferrers_diagram()
   ##
   #
 ##
#
sage: print SkewPartition([[5,4,3,1],[3,1]]).diagram()
   ##
 ###
###
#
ferrers_diagram()

Return the Ferrers diagram of self.

EXAMPLES:

sage: print SkewPartition([[5,4,3,1],[3,3,1]]).ferrers_diagram()
   ##
   #
 ##
#
sage: print SkewPartition([[5,4,3,1],[3,1]]).diagram()
   ##
 ###
###
#
inner()

Returns the inner partition of the skew partition.

EXAMPLES:

sage: SkewPartition([[3,2,1],[1,1]]).inner()
[1, 1]
inner_corners()

Returns a list of the inner corners of the skew partition skp.

EXAMPLES:

sage: SkewPartition([[4, 3, 1], [2]]).inner_corners()
[[0, 2], [1, 0]]
is_connected()

Returns True if self is a connected skew partition.

A skew partition is said to be connected if for each pair of consecutive rows, there are at least two boxes (one in each row) which have a common edge.

EXAMPLES:

sage: SkewPartition([[5,4,3,1],[3,3,1]]).is_connected()
False
sage: SkewPartition([[5,4,3,1],[3,1]]).is_connected()
True
is_overlap(n)

Returns True if n = self.overlap()

See also

overlap()

EXAMPLES:

sage: SkewPartition([[5,4,3,1],[3,1]]).is_overlap(1)
True
jacobi_trudi()

EXAMPLES:

sage: SkewPartition([[3,2,1],[2,1]]).jacobi_trudi()
[h[1]    0    0]
[h[3] h[1]    0]
[h[5] h[3] h[1]]
sage: SkewPartition([[4,3,2],[2,1]]).jacobi_trudi()
[h[2]  h[]    0]
[h[4] h[2]  h[]]
[h[6] h[4] h[2]]
k_conjugate(k)

Returns the k-conjugate of the skew partition.

EXAMPLES:

sage: SkewPartition([[3,2,1],[2,1]]).k_conjugate(3)
[[2, 1, 1, 1, 1], [2, 1]]
sage: SkewPartition([[3,2,1],[2,1]]).k_conjugate(4)
[[2, 2, 1, 1], [2, 1]]
sage: SkewPartition([[3,2,1],[2,1]]).k_conjugate(5)
[[3, 2, 1], [2, 1]]
outer()

Returns the outer partition of the skew partition.

EXAMPLES:

sage: SkewPartition([[3,2,1],[1,1]]).outer()
[3, 2, 1]
outer_corners()

Returns a list of the outer corners of the skew partition skp.

EXAMPLES:

sage: SkewPartition([[4, 3, 1], [2]]).outer_corners()
[[0, 3], [1, 2], [2, 0]]
overlap()

Returns the overlap of self.

The overlap of two consecutive rows in a skew partition is the number of pairs of boxes (one in each row) that share a common edge. This number can be positive, zero, or negative.

The overlap of a skew partition is the minimum of the overlap of the consecutive rows, or infinity in the case of at most one row. If the overlap is positive, then the skew partition is called connected.

EXAMPLES:

sage: SkewPartition([[],[]]).overlap()
+Infinity
sage: SkewPartition([[1],[]]).overlap()
+Infinity
sage: SkewPartition([[10],[]]).overlap()
+Infinity
sage: SkewPartition([[10],[2]]).overlap()
+Infinity
sage: SkewPartition([[10,1],[2]]).overlap()
-1
sage: SkewPartition([[10,10],[1]]).overlap()
9
pieri_macdonald_coeffs()

Computation of the coefficients which appear in the Pieri formula for Macdonald polynomials given in his book ( Chapter 6.6 formula 6.24(ii) )

EXAMPLES:

sage: SkewPartition([[3,2,1],[2,1]]).pieri_macdonald_coeffs()
1
sage: SkewPartition([[3,2,1],[2,2]]).pieri_macdonald_coeffs()
(q^2*t^3 - q^2*t - t^2 + 1)/(q^2*t^3 - q*t^2 - q*t + 1)
sage: SkewPartition([[3,2,1],[2,2,1]]).pieri_macdonald_coeffs()
(q^6*t^8 - q^6*t^6 - q^4*t^7 - q^5*t^5 + q^4*t^5 - q^3*t^6 + q^5*t^3 + 2*q^3*t^4 + q*t^5 - q^3*t^2 + q^2*t^3 - q*t^3 - q^2*t - t^2 + 1)/(q^6*t^8 - q^5*t^7 - q^5*t^6 - q^4*t^6 + q^3*t^5 + 2*q^3*t^4 + q^3*t^3 - q^2*t^2 - q*t^2 - q*t + 1)
sage: SkewPartition([[3,3,2,2],[3,2,2,1]]).pieri_macdonald_coeffs()
(q^5*t^6 - q^5*t^5 + q^4*t^6 - q^4*t^5 - q^4*t^3 + q^4*t^2 - q^3*t^3 - q^2*t^4 + q^3*t^2 + q^2*t^3 - q*t^4 + q*t^3 + q*t - q + t - 1)/(q^5*t^6 - q^4*t^5 - q^3*t^4 - q^3*t^3 + q^2*t^3 + q^2*t^2 + q*t - 1)
quotient(k)

The quotient map extended to skew partitions.

EXAMPLES:

sage: SkewPartition([[3, 3, 2, 1], [2, 1]]).quotient(2)
[[[3], []], [[], []]]
r_quotient(length)
* deprecate *
row_lengths()

Returns the row lengths of the skew partition.

EXAMPLES:

sage: SkewPartition([[3,2,1],[1,1]]).row_lengths()
[2, 1, 1]
rows_intersection_set()

Returns the set of boxes in the lines of lambda which intersect the skew partition.

EXAMPLES:

sage: skp = SkewPartition([[3,2,1],[2,1]])
sage: boxes = Set([ (0,0), (0, 1), (0,2), (1, 0), (1, 1), (2, 0)])
sage: skp.rows_intersection_set() == boxes
True
size()

Returns the size of the skew partition.

EXAMPLES:

sage: SkewPartition([[3,2,1],[1,1]]).size()
4
to_dag()

Returns a directed acyclic graph corresponding to the skew partition.

EXAMPLES:

sage: dag = SkewPartition([[3, 2, 1], [1, 1]]).to_dag()
sage: dag.edges()
[('0,1', '0,2', None), ('0,1', '1,1', None)]
sage: dag.vertices()
['0,1', '0,2', '1,1', '2,0']
to_list()

Returns self as a list of lists.

EXAMPLES:

sage: s = SkewPartition([[4,3,1],[2]])
sage: s.to_list()
[[4, 3, 1], [2]]
sage: type(s.to_list())
<type 'list'>
sage.combinat.skew_partition.SkewPartitions(n=None, row_lengths=None, overlap=0)

Returns the combinatorial class of skew partitions.

EXAMPLES:

sage: SkewPartitions(4)
Skew partitions of 4
sage: SkewPartitions(4).cardinality()
28
sage: SkewPartitions(row_lengths=[2,1,2])
Skew partitions with row lengths [2, 1, 2]
sage: SkewPartitions(4, overlap=2)
Skew partitions of 4 with overlap of 2
sage: SkewPartitions(4, overlap=2).list()
[[[2, 2], []], [[4], []]]
class sage.combinat.skew_partition.SkewPartitions_all
__contains__(x)

TESTS:

sage: [[], []] in SkewPartitions()
True
sage: [[], [1]] in SkewPartitions()
False
sage: [[], [-1]] in SkewPartitions()
False
sage: [[], [0]] in SkewPartitions()
False
sage: [[3,2,1],[]] in SkewPartitions()
True
sage: [[3,2,1],[1]] in SkewPartitions()
True
sage: [[3,2,1],[2]] in SkewPartitions()
True
sage: [[3,2,1],[3]] in SkewPartitions()
True
sage: [[3,2,1],[4]] in SkewPartitions()
False            
sage: [[3,2,1],[1,1]] in SkewPartitions()
True
sage: [[3,2,1],[1,2]] in SkewPartitions()
False
sage: [[3,2,1],[2,1]] in SkewPartitions()
True
sage: [[3,2,1],[2,2]] in SkewPartitions()
True
sage: [[3,2,1],[3,2]] in SkewPartitions()
True
sage: [[3,2,1],[1,1,1]] in SkewPartitions()
True
sage: [[7, 4, 3, 2], [8, 2, 1]] in SkewPartitions()
False
sage: [[7, 4, 3, 2], [5, 2, 1]] in SkewPartitions()
True
sage: [[4,2,1],[1,1,1,1]] in SkewPartitions()
False
__init__()

TESTS:

sage: S = SkewPartitions()
sage: S == loads(dumps(S))
True
__repr__()

TESTS:

sage: repr(SkewPartitions())
'Skew partitions'
list()

TESTS:

sage: SkewPartitions().list()
...
NotImplementedError
object_class
alias of SkewPartition_class
class sage.combinat.skew_partition.SkewPartitions_n(n, overlap=0)
__contains__(x)

TESTS:

sage: [[],[]] in SkewPartitions(0)
True
sage: [[3,2,1], []] in SkewPartitions(6)
True
sage: [[3,2,1], []] in SkewPartitions(7)
False
sage: [[3,2,1], []] in SkewPartitions(5)
False
sage: [[7, 4, 3, 2], [8, 2, 1]] in SkewPartitions(8)
False
sage: [[7, 4, 3, 2], [5, 2, 1]] in SkewPartitions(8)
False
sage: [[7, 4, 3, 2], [5, 2, 1]] in SkewPartitions(5)
False
sage: [[7, 4, 3, 2], [5, 2, 1]] in SkewPartitions(5, overlap=-1)
False
sage: [[7, 4, 3, 2], [5, 2, 1]] in SkewPartitions(8, overlap=-1)
True
sage: [[7, 4, 3, 2], [5, 2, 1]] in SkewPartitions(8, overlap=0)
False
sage: [[7, 4, 3, 2], [5, 2, 1]] in SkewPartitions(8, overlap='connected')
False
sage: [[7, 4, 3, 2], [5, 2, 1]] in SkewPartitions(8, overlap=-2)
True
__init__(n, overlap=0)

TESTS:

sage: S = SkewPartitions(3)
sage: S == loads(dumps(S))
True
sage: S = SkewPartitions(3, overlap=1)
sage: S == loads(dumps(S))
True
__repr__()

TESTS:

sage: repr(SkewPartitions(3))
'Skew partitions of 3'
sage: repr(SkewPartitions(3, overlap=1))
'Skew partitions of 3 with overlap of 1'
_count_slide(co, overlap=0)

Returns the number of skew partitions related to the composition co by ‘sliding’. The composition co is the list of row lengths of the skew partition.

EXAMPLES:

sage: s = SkewPartitions(3)
sage: s._count_slide([2,1])
2
sage: [ sp for sp in s if sp.row_lengths() == [2,1] ]
[[[2, 1], []], [[3, 1], [1]]]
sage: s = SkewPartitions(3, overlap=1)            
sage: s._count_slide([2,1], overlap=1)
1
sage: [ sp for sp in s if sp.row_lengths() == [2,1] ]
[[[2, 1], []]]
cardinality()

Returns the number of skew partitions of the integer n.

EXAMPLES:

sage: SkewPartitions(0).cardinality()
1
sage: SkewPartitions(4).cardinality()
28
sage: SkewPartitions(5).cardinality()
87
sage: SkewPartitions(4, overlap=1).cardinality()
9
sage: SkewPartitions(5, overlap=1).cardinality()
20
sage: s = SkewPartitions(5, overlap=-1)
sage: s.cardinality() == len(s.list())
True
list()

Returns a list of the skew partitions of n.

EXAMPLES:

sage: SkewPartitions(3).list()
[[[1, 1, 1], []],
 [[2, 2, 1], [1, 1]],
 [[2, 1, 1], [1]],
 [[3, 2, 1], [2, 1]],
 [[2, 2], [1]],
 [[3, 2], [2]],
 [[2, 1], []],
 [[3, 1], [1]],
 [[3], []]]
sage: SkewPartitions(3, overlap=0).list()
[[[1, 1, 1], []],
 [[2, 2, 1], [1, 1]],
 [[2, 1, 1], [1]],
 [[3, 2, 1], [2, 1]],
 [[2, 2], [1]],
 [[3, 2], [2]],
 [[2, 1], []],
 [[3, 1], [1]],
 [[3], []]]
sage: SkewPartitions(3, overlap=1).list()
[[[1, 1, 1], []], [[2, 2], [1]], [[2, 1], []], [[3], []]]
sage: SkewPartitions(3, overlap=2).list()
[[[3], []]]
sage: SkewPartitions(3, overlap=3).list()
[[[3], []]]
sage: SkewPartitions(3, overlap=4).list()
[]
object_class
alias of SkewPartition_class
class sage.combinat.skew_partition.SkewPartitions_rowlengths(co, overlap=0)

The combinatorial class of all skew partitions with given row lengths.

__contains__(x)

EXAMPLES:

sage: [[4,3,1],[2]] in SkewPartitions(row_lengths=[2,3,1])
True
sage: [[4,3,1],[2]] in SkewPartitions(row_lengths=[2,1,3])
False
sage: [[5,4,3,1],[3,3,1]] in SkewPartitions(row_lengths=[2,1,1,2])
False
sage: [[5,4,3,1],[3,3,1]] in SkewPartitions(row_lengths=[2,1,2,1])
True
__init__(co, overlap=0)

TESTS:

sage: S = SkewPartitions(row_lengths=[2,1])
sage: S == loads(dumps(S))
True
__repr__()

TESTS:

sage: repr(SkewPartitions(row_lengths=[2,1]))
'Skew partitions with row lengths [2, 1]'
_from_row_lengths_aux(sskp, ck_1, ck, overlap=0)

EXAMPLES:

sage: s = SkewPartitions(row_lengths=[2,1])
sage: s._from_row_lengths_aux([[1], []], 1, 1, overlap=0)
[[[1, 1], []], [[2, 1], [1]]]
sage: s._from_row_lengths_aux([[1, 1], []], 1, 1, overlap=0)
[[[1, 1, 1], []], [[2, 2, 1], [1, 1]]]
sage: s._from_row_lengths_aux([[2, 1], [1]], 1, 1, overlap=0)
[[[2, 1, 1], [1]], [[3, 2, 1], [2, 1]]]
sage: s._from_row_lengths_aux([[1], []], 1, 2, overlap=0)
[[[2, 2], [1]], [[3, 2], [2]]]
sage: s._from_row_lengths_aux([[2], []], 2, 1, overlap=0)
[[[2, 1], []], [[3, 1], [1]]]
list()

Returns a list of all the skew partitions that have row lengths given by the composition self.co.

EXAMPLES:

sage: SkewPartitions(row_lengths=[2,2]).list()
[[[2, 2], []], [[3, 2], [1]], [[4, 2], [2]]]
sage: SkewPartitions(row_lengths=[2,2], overlap=1).list()
[[[2, 2], []], [[3, 2], [1]]]
object_class
alias of SkewPartition_class
sage.combinat.skew_partition.row_lengths_aux(skp)

EXAMPLES:

sage: from sage.combinat.skew_partition import row_lengths_aux
sage: row_lengths_aux([[5,4,3,1],[3,3,1]])
[2, 1, 2]
sage: row_lengths_aux([[5,4,3,1],[3,1]])
[2, 3]

Previous topic

Set Partitions

Next topic

Subsets

This Page