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 cells, in the same way as a partition. Only the cells 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 cells (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, with no empty row nor empty column:
sage: SkewPartitions(3).cardinality()
9
sage: SkewPartitions(3).list()
[[3] / [],
[2, 1] / [],
[3, 1] / [1],
[2, 2] / [1],
[3, 2] / [2],
[1, 1, 1] / [],
[2, 2, 1] / [1, 1],
[2, 1, 1] / [1],
[3, 2, 1] / [2, 1]]
There are 4 connected skew partitions of size 3:
sage: SkewPartitions(3, overlap=1).cardinality()
4
sage: SkewPartitions(3, overlap=1).list()
[[3] / [], [2, 1] / [], [2, 2] / [1], [1, 1, 1] / []]
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_trudi()
method computes the JacobiTrudi matrix. See
[Mac1995] 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)]
AUTHORS:
 Mike Hansen: Initial version
 Travis Scrimshaw (20130211): Factored out
CombinatorialClass

class
sage.combinat.skew_partition.
SkewPartition
(parent, skp)¶ Bases:
sage.combinat.combinat.CombinatorialElement
A skew partition.
A skew partition of shape \(\lambda / \mu\) is the Young diagram from the partition \(\lambda\) and removing the partition \(\mu\) from the upperleft corner in English convention.

cell_poset
(orientation='SE')¶ Return the Young diagram of
self
as a poset. The optional keyword variableorientation
determines the order relation of the poset.The poset always uses the set of cells of the Young diagram of
self
as its ground set. The order relation of the poset depends on theorientation
variable (which defaults to"SE"
). Concretely,orientation
has to be specified to one of the strings"NW"
,"NE"
,"SW"
, and"SE"
, standing for “northwest”, “northeast”, “southwest” and “southeast”, respectively. Iforientation
is"SE"
, then the order relation of the poset is such that a cell \(u\) is greater or equal to a cell \(v\) in the poset if and only if \(u\) lies weakly southeast of \(v\) (this means that \(u\) can be reached from \(v\) by a sequence of south and east steps; the sequence is allowed to consist of south steps only, or of east steps only, or even be empty). Similarly the order relation is defined for the other three orientations. The Young diagram is supposed to be drawn in English notation.The elements of the poset are the cells of the Young diagram of
self
, written as tuples of zerobased coordinates (so that \((3, 7)\) stands for the \(8\)th cell of the \(4\)th row, etc.).EXAMPLES:
sage: p = SkewPartition([[3,3,1], [2,1]]) sage: Q = p.cell_poset(); Q Finite poset containing 4 elements sage: sorted(Q) [(0, 2), (1, 1), (1, 2), (2, 0)] sage: sorted(Q.maximal_elements()) [(1, 2), (2, 0)] sage: sorted(Q.minimal_elements()) [(0, 2), (1, 1), (2, 0)] sage: sorted(Q.upper_covers((1, 1))) [(1, 2)] sage: sorted(Q.upper_covers((0, 2))) [(1, 2)] sage: P = p.cell_poset(orientation="NW"); P Finite poset containing 4 elements sage: sorted(P) [(0, 2), (1, 1), (1, 2), (2, 0)] sage: sorted(P.minimal_elements()) [(1, 2), (2, 0)] sage: sorted(P.maximal_elements()) [(0, 2), (1, 1), (2, 0)] sage: sorted(P.upper_covers((1, 2))) [(0, 2), (1, 1)] sage: R = p.cell_poset(orientation="NE"); R Finite poset containing 4 elements sage: sorted(R) [(0, 2), (1, 1), (1, 2), (2, 0)] sage: R.maximal_elements() [(0, 2)] sage: R.minimal_elements() [(2, 0)] sage: R.upper_covers((2, 0)) [(1, 1)] sage: sorted([len(R.upper_covers(v)) for v in R]) [0, 1, 1, 1]

cells
()¶ Return the coordinates of the cells of
self
. Coordinates are given as(rowindex, columnindex)
and are 0 based.EXAMPLES:
sage: SkewPartition([[4, 3, 1], [2]]).cells() [(0, 2), (0, 3), (1, 0), (1, 1), (1, 2), (2, 0)] sage: SkewPartition([[4, 3, 1], []]).cells() [(0, 0), (0, 1), (0, 2), (0, 3), (1, 0), (1, 1), (1, 2), (2, 0)] sage: SkewPartition([[2], []]).cells() [(0, 0), (0, 1)]

column_lengths
()¶ Return the column lengths of
self
.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
()¶ Return the set of cells in the columns of the outer shape of
self
which columns intersect the skew diagram ofself
.EXAMPLES:
sage: skp = SkewPartition([[3,2,1],[2,1]]) sage: cells = Set([ (0,0), (0, 1), (0,2), (1, 0), (1, 1), (2, 0)]) sage: skp.columns_intersection_set() == cells True

conjugate
()¶ Return 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()) ** *** *** * sage: SkewPartitions.options(diagram_str='#', convention="French") sage: print(SkewPartition([[5,4,3,1],[3,1]]).diagram()) # ### ### ## sage: SkewPartitions.options._reset()

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()) ** *** *** * sage: SkewPartitions.options(diagram_str='#', convention="French") sage: print(SkewPartition([[5,4,3,1],[3,1]]).diagram()) # ### ### ## sage: SkewPartitions.options._reset()

frobenius_rank
()¶ Return the Frobenius rank of the skew partition
self
.The Frobenius rank of a skew partition \(\lambda / \mu\) can be defined in various ways. The quickest one is probably the following: Writing \(\lambda\) as \((\lambda_1, \lambda_2, \cdots , \lambda_N)\), and writing \(\mu\) as \((\mu_1, \mu_2, \cdots , \mu_N)\), we define the Frobenius rank of \(\lambda / \mu\) to be the number of all \(1 \leq i \leq N\) such that
\[\lambda_i  i \not\in \{ \mu_1  1, \mu_2  2, \cdots , \mu_N  N \}.\]In other words, the Frobenius rank of \(\lambda / \mu\) is the number of rows in the JacobiTrudi matrix of \(\lambda / \mu\) which don’t contain \(h_0\). Further definitions have been considered in [Sta2002] (where Frobenius rank is just being called rank).
If \(\mu\) is the empty shape, then the Frobenius rank of \(\lambda / \mu\) is just the usual Frobenius rank of the partition \(\lambda\) (see
frobenius_rank()
).EXAMPLES:
sage: SkewPartition([[8,8,7,4], [4,1,1]]).frobenius_rank() 4 sage: SkewPartition([[2,1], [1]]).frobenius_rank() 2 sage: SkewPartition([[2,1,1], [1]]).frobenius_rank() 2 sage: SkewPartition([[2,1,1], [1,1]]).frobenius_rank() 2 sage: SkewPartition([[5,4,3,2], [2,1,1]]).frobenius_rank() 3 sage: SkewPartition([[4,2,1], [3,1,1]]).frobenius_rank() 2 sage: SkewPartition([[4,2,1], [3,2,1]]).frobenius_rank() 1
If the inner shape is empty, then the Frobenius rank of the skew partition is just the standard Frobenius rank of the partition:
sage: all( SkewPartition([lam, Partition([])]).frobenius_rank() ....: == lam.frobenius_rank() for i in range(6) ....: for lam in Partitions(i) ) True
If the inner and outer shapes are equal, then the Frobenius rank is zero:
sage: all( SkewPartition([lam, lam]).frobenius_rank() == 0 ....: for i in range(6) for lam in Partitions(i) ) True

inner
()¶ Return the inner partition of
self
.EXAMPLES:
sage: SkewPartition([[3,2,1],[1,1]]).inner() [1, 1]

inner_corners
()¶ Return a list of the inner corners of
self
.EXAMPLES:
sage: SkewPartition([[4, 3, 1], [2]]).inner_corners() [(0, 2), (1, 0)] sage: SkewPartition([[4, 3, 1], []]).inner_corners() [(0, 0)]

is_connected
()¶ Return
True
ifself
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 cells (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)¶ Return
True
if the overlap ofself
is at mostn
.See also
EXAMPLES:
sage: SkewPartition([[5,4,3,1],[3,1]]).is_overlap(1) True

is_ribbon
()¶ Return
True
if and only ifself
is a ribbon, that is, if it has exactly one cell in each of \(q\) consecutive diagonals for some nonnegative integer \(q\).EXAMPLES:
sage: P=SkewPartition([[4,4,3,3],[3,2,2]]) sage: P.pp() * ** * *** sage: P.is_ribbon() True sage: P=SkewPartition([[4,3,3],[1,1]]) sage: P.pp() *** ** *** sage: P.is_ribbon() False sage: P=SkewPartition([[4,4,3,2],[3,2,2]]) sage: P.pp() * ** * ** sage: P.is_ribbon() False sage: P=SkewPartition([[4,4,3,3],[4,2,2,1]]) sage: P.pp() ** * ** sage: P.is_ribbon() True sage: P=SkewPartition([[4,4,3,3],[4,2,2]]) sage: P.pp() ** * *** sage: P.is_ribbon() True sage: SkewPartition([[2,2,1],[2,2,1]]).is_ribbon() True

jacobi_trudi
()¶ Return the JacobiTrudi matrix of
self
.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)¶ Return 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
()¶ Return the outer partition of
self
.EXAMPLES:
sage: SkewPartition([[3,2,1],[1,1]]).outer() [3, 2, 1]

outer_corners
()¶ Return a list of the outer corners of
self
.EXAMPLES:
sage: SkewPartition([[4, 3, 1], [2]]).outer_corners() [(0, 3), (1, 2), (2, 0)]

overlap
()¶ Return the overlap of
self
.The overlap of two consecutive rows in a skew partition is the number of pairs of cells (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)

pp
()¶ Prettyprint
self
.EXAMPLES:
sage: SkewPartition([[5,4,3,1],[3,3,1]]).pp() ** * ** *

quotient
(k)¶ The quotient map extended to skew partitions.
EXAMPLES:
sage: SkewPartition([[3, 3, 2, 1], [2, 1]]).quotient(2) [[3] / [], [] / []]

row_lengths
()¶ Return the row lengths of
self
.EXAMPLES:
sage: SkewPartition([[3,2,1],[1,1]]).row_lengths() [2, 1, 1]

rows_intersection_set
()¶ Return the set of cells in the rows of the outer shape of
self
which rows intersect the skew diagram ofself
.EXAMPLES:
sage: skp = SkewPartition([[3,2,1],[2,1]]) sage: cells = Set([ (0,0), (0, 1), (0,2), (1, 0), (1, 1), (2, 0)]) sage: skp.rows_intersection_set() == cells True

size
()¶ Return the size of
self
.EXAMPLES:
sage: SkewPartition([[3,2,1],[1,1]]).size() 4

to_dag
(format='string')¶ Return a directed acyclic graph corresponding to the skew partition
self
.The directed acyclic graph corresponding to a skew partition \(p\) is the digraph whose vertices are the cells of \(p\), and whose edges go from each cell to its lower and right neighbors (in English notation).
INPUT:
format
– either'string'
or'tuple'
(default:'string'
); determines whether the vertices of the resulting dag will be strings or 2tuples of coordinates
EXAMPLES:
sage: dag = SkewPartition([[3, 3, 1], [1, 1]]).to_dag() sage: dag.edges() [('0,1', '0,2', None), ('0,1', '1,1', None), ('0,2', '1,2', None), ('1,1', '1,2', None)] sage: dag.vertices() ['0,1', '0,2', '1,1', '1,2', '2,0'] sage: dag = SkewPartition([[3, 2, 1], [1, 1]]).to_dag(format="tuple") 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
()¶ Return
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()) <... 'list'>


class
sage.combinat.skew_partition.
SkewPartitions
(is_infinite=False)¶ Bases:
sage.structure.unique_representation.UniqueRepresentation
,sage.structure.parent.Parent
Skew partitions.
Warning
The iterator of this class only yields skew partitions which are reduced, in the sense that there are no empty rows before the last nonempty row, and there are no empty columns before the last nonempty column.
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 a minimum overlap of 2 sage: SkewPartitions(4, overlap=2).list() [[4] / [], [2, 2] / []]

Element
¶ alias of
SkewPartition

from_row_and_column_length
(rowL, colL)¶ Construct a partition from its row lengths and column lengths.
INPUT:
rowL
– A composition or a list of positive integerscolL
– A composition or a list of positive integers
OUTPUT:
 If it exists the unique skewpartitions with row lengths
rowL
and column lengthscolL
.  Raise a
ValueError
ifrowL
andcolL
are not compatible.
EXAMPLES:
sage: S = SkewPartitions() sage: print(S.from_row_and_column_length([3,1,2,2],[2,3,1,1,1]).diagram()) *** * ** ** sage: S.from_row_and_column_length([],[]) [] / [] sage: S.from_row_and_column_length([1],[1]) [1] / [] sage: S.from_row_and_column_length([2,1],[2,1]) [2, 1] / [] sage: S.from_row_and_column_length([1,2],[1,2]) [2, 2] / [1] sage: S.from_row_and_column_length([1,2],[1,3]) Traceback (most recent call last): ... ValueError: Sum mismatch : [1, 2] and [1, 3] sage: S.from_row_and_column_length([3,2,1,2],[2,3,1,1,1]) Traceback (most recent call last): ... ValueError: Incompatible row and column length : [3, 2, 1, 2] and [2, 3, 1, 1, 1]
Warning
If some rows and columns have length zero, there is no way to retrieve unambiguously the skew partition. We therefore raise a
ValueError
. For examples here are two skew partitions with the same row and column lengths:sage: skp1 = SkewPartition([[2,2],[2,2]]) sage: skp2 = SkewPartition([[2,1],[2,1]]) sage: skp1.row_lengths(), skp1.column_lengths() ([0, 0], [0, 0]) sage: skp2.row_lengths(), skp2.column_lengths() ([0, 0], [0, 0]) sage: SkewPartitions().from_row_and_column_length([0,0], [0,0]) Traceback (most recent call last): ... ValueError: row and column length must be positive

options
(*get_value, **set_value)¶ Sets and displays the options for elements of the skew partition classes. If no parameters are set, then the function returns a copy of the options dictionary.
The
options
to skew partitions can be accessed as the methodSkewPartitions.options
ofSkewPartitions
and related parent classes.OPTIONS:
convention
– (default:English
) Sets the convention used for displaying tableaux and partitionsEnglish
– use the English conventionFrench
– use the French convention
diagram_str
– (default:*
) The character used for the cells when printing Ferrers diagramsdisplay
– (default:quotient
) Specifies how skew partitions should be printedarray
– alias fordiagram
diagram
– as a skew Ferrers diagramferrers_diagram
– alias fordiagram
lists
– displayed as a pair of listspair
– alias forlists
quotient
– displayed as a quotient of partitionsyoung_diagram
– alias fordiagram
latex
– (default:young_diagram
) Specifies how skew partitions should be latexedarray
– alias fordiagram
diagram
– latex as a skew Ferrers diagramferrers_diagram
– alias fordiagram
marked
– latex as a partition where the skew shape is markedyoung_diagram
– latex as a skew Young diagram
latex_diagram_str
– (default:\ast
) The character used for the cells when latexing Ferrers diagramslatex_marking_str
– (default:X
) The character used to marked the deleted cells when latexing marked partitionsnotation
– alternative name forconvention
EXAMPLES:
sage: SP = SkewPartition([[4,2,2,1], [3, 1, 1]]) sage: SP [4, 2, 2, 1] / [3, 1, 1] sage: SkewPartitions.options.display="lists" sage: SP [[4, 2, 2, 1], [3, 1, 1]]
Changing the
convention
for skew partitions also changes theconvention
option for partitions and tableaux and vice versa:sage: SkewPartitions.options(display="diagram", convention='French') sage: SP * * * * sage: T = Tableau([[1,2,3],[4,5]]) sage: T.pp() 4 5 1 2 3 sage: P = Partition([4, 2, 2, 1]) sage: P.pp() * ** ** **** sage: Tableaux.options.convention="english" sage: SP * * * * sage: T.pp() 1 2 3 4 5 sage: SkewPartitions.options._reset()
See
GlobalOptions
for more features of these options.


class
sage.combinat.skew_partition.
SkewPartitions_all
¶ Bases:
sage.combinat.skew_partition.SkewPartitions
Class of all skew partitions.

class
sage.combinat.skew_partition.
SkewPartitions_n
(n, overlap)¶ Bases:
sage.combinat.skew_partition.SkewPartitions
The set of skew partitions of
n
with overlap at leastoverlap
and no empty row.INPUT:
n
– a nonnegative integeroverlap
– an integer (default: \(0\))
Caveat: this set is stable under conjugation only for
overlap
equal to 0 or 1. What exactly happens for negative overlaps is not yet well specified and subject to change (we may want to introduce vertical overlap constraints as well).Todo
As is, this set is essentially the composition of
Compositions(n)
(which give the row lengths) andSkewPartition(n, row_lengths=...)
, and one would want to “inherit” list and cardinality from this composition.
cardinality
()¶ Return the number of skew partitions of the integer \(n\) (with given overlap, if specified; and with no empty rows before the last row).
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

class
sage.combinat.skew_partition.
SkewPartitions_rowlengths
(co, overlap)¶ Bases:
sage.combinat.skew_partition.SkewPartitions
All skew partitions with given row lengths.

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]