Coverage for local/lib/python2.7/site-packages/sage/combinat/skew_partition.py : 76%

# -*- coding: utf-8 -*- 

r""" 

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 :meth:`jacobi_trudi()` method computes the Jacobi-Trudi matrix. See 

[Mac95]_ 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)] 

REFERENCES: 

.. [Mac95] Macdonald I.-G., (1995), "Symmetric Functions and Hall 

Polynomials", Oxford Science Publication 

AUTHORS: 

- Mike Hansen: Initial version 

- Travis Scrimshaw (2013-02-11): Factored out ``CombinatorialClass`` 

""" 

#***************************************************************************** 

# Copyright (C) 2007 Mike Hansen <mhansen@gmail.com>, 

# 

# 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: 

# 

# http://www.gnu.org/licenses/ 

#***************************************************************************** 

from __future__ import print_function 

from six.moves import range 

from sage.structure.global_options import GlobalOptions 

from sage.structure.parent import Parent 

from sage.structure.unique_representation import UniqueRepresentation 

from sage.categories.infinite_enumerated_sets import InfiniteEnumeratedSets 

from sage.categories.finite_enumerated_sets import FiniteEnumeratedSets 

from sage.rings.all import ZZ, QQ 

from sage.sets.set import Set 

from sage.graphs.digraph import DiGraph 

from sage.matrix.matrix_space import MatrixSpace 

from sage.combinat.combinat import CombinatorialElement 

from sage.combinat.partition import Partitions, _Partitions 

from sage.combinat.tableau import Tableaux 

from sage.combinat.composition import Compositions 

class SkewPartition(CombinatorialElement): 

r""" 

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 upper-left 

corner in English convention. 

""" 

@staticmethod 

def __classcall_private__(cls, skp): 

""" 

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

""" 

skp = [_Partitions(_) for _ in skp] 

if skp not in SkewPartitions(): 

raise ValueError("invalid skew partition: %s"%skp) 

return SkewPartitions()(skp) 

def __init__(self, parent, skp): 

""" 

TESTS:: 

sage: skp = SkewPartition([[3,2,1],[2,1]]) 

sage: TestSuite(skp).run() 

""" 

CombinatorialElement.__init__(self, parent, 

[_Partitions(skp[0]), _Partitions(skp[1])]) 

def _repr_(self): 

""" 

Return a string representation of ``self``. 

For more on the display options, see 

:obj:`SkewPartitions.options`. 

EXAMPLES:: 

sage: SkewPartition([[3,2,1],[2,1]]) 

[3, 2, 1] / [2, 1] 

""" 

return self.parent().options._dispatch(self, '_repr_', 'display') 

def _repr_quotient(self): 

""" 

Return a string representation of ``self``. 

EXAMPLES:: 

sage: print(SkewPartition([[3,2,1],[2,1]])._repr_quotient()) 

[3, 2, 1] / [2, 1] 

""" 

return "%s / %s"%(self[0], self[1]) 

def _repr_lists(self): 

""" 

Return a string representation of ``self`` as a pair of lists. 

EXAMPLES:: 

sage: print(SkewPartition([[3,2,1],[2,1]])._repr_lists()) 

[[3, 2, 1], [2, 1]] 

""" 

return repr([list(_) for _ in self]) 

def _latex_(self): 

r""" 

Return a `\LaTeX` representation of ``self``. 

For more on the latex options, see 

:obj:`SkewPartitions.options`. 

EXAMPLES:: 

sage: s = SkewPartition([[5,4,3],[3,1,1]]) 

sage: latex(s) 

{\def\lr#1{\multicolumn{1}{|@{\hspace{.6ex}}c@{\hspace{.6ex}}|}{\raisebox{-.3ex}{$#1$}}} 

\raisebox{-.6ex}{$\begin{array}[b]{*{5}c}\cline{4-5} 

&&&\lr{\phantom{x}}&\lr{\phantom{x}}\\\cline{2-5} 

&\lr{\phantom{x}}&\lr{\phantom{x}}&\lr{\phantom{x}}\\\cline{2-4} 

&\lr{\phantom{x}}&\lr{\phantom{x}}\\\cline{2-3} 

\end{array}$} 

} 

""" 

return self.parent().options._dispatch(self, '_latex_', 'latex') 

def _latex_diagram(self): 

r""" 

Return a `\LaTeX` representation as a young diagram. 

EXAMPLES:: 

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

{\def\lr#1{\multicolumn{1}{|@{\hspace{.6ex}}c@{\hspace{.6ex}}|}{\raisebox{-.3ex}{$#1$}}} 

\raisebox{-.6ex}{$\begin{array}[b]{*{5}c}\cline{4-5} 

&&&\lr{\ast}&\lr{\ast}\\\cline{2-5} 

&\lr{\ast}&\lr{\ast}&\lr{\ast}\\\cline{2-4} 

&\lr{\ast}&\lr{\ast}\\\cline{2-3} 

\end{array}$} 

} 

""" 

if len(self._list) == 0: 

return "{\\emptyset}" 

char = self.parent().options.latex_diagram_str 

from sage.combinat.output import tex_from_array 

arr = [[char]*row_size for row_size in self[0]] 

for i, skew_size in enumerate(self[1]): # This is always smaller by containment 

for j in range(skew_size): 

arr[i][j] = None 

return tex_from_array(arr) 

def _latex_young_diagram(self): 

r""" 

Return a `\LaTeX` representation of ``self`` as a young diagram. 

EXAMPLES:: 

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

{\def\lr#1{\multicolumn{1}{|@{\hspace{.6ex}}c@{\hspace{.6ex}}|}{\raisebox{-.3ex}{$#1$}}} 

\raisebox{-.6ex}{$\begin{array}[b]{*{5}c}\cline{4-5} 

&&&\lr{\phantom{x}}&\lr{\phantom{x}}\\\cline{2-5} 

&\lr{\phantom{x}}&\lr{\phantom{x}}&\lr{\phantom{x}}\\\cline{2-4} 

&\lr{\phantom{x}}&\lr{\phantom{x}}\\\cline{2-3} 

\end{array}$} 

} 

""" 

if len(self._list) == 0: 

return "{\\emptyset}" 

from sage.combinat.output import tex_from_array 

arr = [["\\phantom{x}"]*row_size for row_size in self[0]] 

for i, skew_size in enumerate(self[1]): # This is always smaller by containment 

for j in range(skew_size): 

arr[i][j] = None 

return tex_from_array(arr) 

def _latex_marked(self): 

r""" 

Return a `\LaTeX` representation as a marked partition. 

EXAMPLES:: 

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

{\def\lr#1{\multicolumn{1}{|@{\hspace{.6ex}}c@{\hspace{.6ex}}|}{\raisebox{-.3ex}{$#1$}}} 

\raisebox{-.6ex}{$\begin{array}[b]{*{5}c}\cline{1-5} 

\lr{X}&\lr{X}&\lr{X}&\lr{\phantom{x}}&\lr{\phantom{x}}\\\cline{1-5} 

\lr{X}&\lr{\phantom{x}}&\lr{\phantom{x}}&\lr{\phantom{x}}\\\cline{1-4} 

\lr{X}&\lr{\phantom{x}}&\lr{\phantom{x}}\\\cline{1-3} 

\end{array}$} 

} 

""" 

if len(self._list) == 0: 

return "{\\emptyset}" 

from sage.combinat.output import tex_from_array 

char = self.parent().options.latex_marking_str 

arr = [["\\phantom{x}"]*row_size for row_size in self[0]] 

for i, skew_size in enumerate(self[1]): # This is always smaller by containment 

for j in range(skew_size): 

arr[i][j] = char 

return tex_from_array(arr) 

def __setstate__(self, state): 

r""" 

In order to maintain backwards compatibility and be able to unpickle 

a old pickle from ``SkewPartition_class`` we have to override the 

default ``__setstate__``. 

EXAMPLES:: 

sage: loads(b'x\x9c\x85P\xcbN\xc2@\x14\r\x08>\x06\xf1\xfd~\xbb+.\x9a\xa8\xdf\xe0\xc2McJ\xba4\x93i\xb9v&\xb4\x03w\x1e!,Ht!\xfe\xb6Sh1\xb0qw\xce}\x9c{\xee\xf9\xac\'\x9a\xa5\xe0\'\x83<\x16\x92\x19_\xf7aD\x87L\x19a\xc4@\x92\xae\xa3o\x15\xa3I\xc6\xb4&X\xeb|a}\x82k^\xd4\xa4\x9ci\x8e\x8d\xc0\xa1Lh\x83\xcdw\\\xf7\xe6\x92\xda(\x9b\x18\xab\xc0\xef\x8d%\xcbER\xae/3\xdc\xf0\xa2\x87\xc5\x05MY\x96\xd1\x910\x9c&\xcc@:Pc\x1f2\xc8A\x9a\xf9<n\xae\xf8\xfd\xb3\xba\x10!\xb8\x95P\x1a[\x91\x19!)%)\x18f\x8c"HV\x8dY)\xd0\x02U0T\xa0\xdd\r6[\xb7RA\xcf&@\xb0U\x1e\x9b[\x11\xa0}!?\x84\x14\x06(H\x9b\x83r\x8d\x1e\xd5`4y-\x1b/\x8bz\xb7(\xe3vg\xf2\x83\xed\x10w\xa2\xf6\xf2#\xbb\xd3\x10\xf7\xa6\xb8\x1f\x04\x81\t\xf1\xc0Ez\xc8[\xff?7K\x88\xe0Q!{\x1c\xe2\xc9\x04O=\xde\x08\xb8\x0b\xfe\xac\x0c^\t\x99\x16N\x9diP$g}\xa0\x15\xc1\xf3\xa8\xf6\xfc\x1d\xe2\x05w\xe0\xc9\x81\xcb\x02<:p\x05v\x1a\xf3\xc2\xc65w\xa27\x95\xe8\xadWM\xdcU\xe0\xbe\x18\x05\x1b\xfb\xbf\x8e\x7f\xcc\xbb') 

[3, 2, 1] / [1, 1] 

sage: loads(dumps( SkewPartition([[3,2,1], [1,1]]) )) 

[3, 2, 1] / [1, 1] 

""" 

if isinstance(state, dict): # for old pickles from SkewPartition_class 

self._set_parent(SkewPartitions()) 

self.__dict__ = state 

else: 

self._set_parent(state[0]) 

self.__dict__ = state[1] 

def ferrers_diagram(self): 

""" 

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() 

""" 

char, convention = self.parent().options('diagram_str', 'convention') 

if convention == "English": 

L = range(len(self[0])) 

else: 

L = reversed(range(len(self[0]))) 

s = "" 

for i in L: 

if len(self[1]) > i: 

s += " "*self[1][i] 

s += char*(self[0][i]-self[1][i]) 

else: 

s += char*self[0][i] 

s += "\n" 

return s[:-1] 

diagram = ferrers_diagram 

_repr_diagram = ferrers_diagram 

def pp(self): 

""" 

Pretty-print ``self``. 

EXAMPLES:: 

sage: SkewPartition([[5,4,3,1],[3,3,1]]).pp() 

** 

* 

** 

* 

""" 

print(self.ferrers_diagram()) 

def _ascii_art_(self): 

""" 

TESTS:: 

sage: ascii_art(SkewPartitions(3).list()) 

[ * * * * ] 

[ ** ** * * * * * * ] 

[ ***, * , * , **, ** , *, * , * , * ] 

sage: SkewPartitions.options(diagram_str='#', convention="French") 

sage: ascii_art(SkewPartitions(3).list()) 

[ # # # # ] 

[ # # ## ## # # # # ] 

[ ###, ##, ##, #, #, #, #, #, # ] 

sage: SkewPartitions.options._reset() 

""" 

from sage.typeset.ascii_art import AsciiArt 

return AsciiArt(self.diagram().splitlines()) 

def _unicode_art_(self): 

""" 

.. WARNING:: 

not working in presence of empty lines 

TESTS:: 

sage: unicode_art(SkewPartitions(3).list()) 

⎡ ┌┐ ┌┐ ┌┐ ┌┐ ⎤ 

⎢ ┌┬┐ ┌┬┐ ┌┐ ┌┐ ├┤ ├┤ ┌┼┘ ┌┼┘ ⎥ 

⎢ ┌┬┬┐ ├┼┘ ┌┼┴┘ ┌┼┤ ┌┬┼┘ ├┤ ┌┼┘ ├┤ ┌┼┘ ⎥ 

⎣ └┴┴┘, └┘ , └┘ , └┴┘, └┴┘ , └┘, └┘ , └┘ , └┘ ⎦ 

sage: SkewPartitions.options.convention = "French" 

sage: unicode_art(SkewPartitions(3).list()) 

⎡ ┌┐ ┌┐ ┌┐ ┌┐ ⎤ 

⎢ ┌┐ ┌┐ ┌┬┐ ┌┬┐ ├┤ └┼┐ ├┤ └┼┐ ⎥ 

⎢ ┌┬┬┐ ├┼┐ └┼┬┐ └┼┤ └┴┼┐ ├┤ ├┤ └┼┐ └┼┐ ⎥ 

⎣ └┴┴┘, └┴┘, └┴┘, └┘, └┘, └┘, └┘, └┘, └┘ ⎦ 

sage: SkewPartitions.options._reset() 

sage: unicode_art(SkewPartition([[3,1],[2]])) 

┌┐ 

┌┬┴┘ 

└┘ 

""" 

out, inn = self 

inn = inn + [0] * (len(out) - len(inn)) 

if not self._list: 

return u'∅' 

if self.parent().options.convention == "French": 

s, t, b, l, r, tr, tl, br, bl, x, h = list(u' ┴┬├┤┘└┐┌┼─') 

else: 

s, t, b, l, r, tr, tl, br, bl, x, h = list(u' ┬┴├┤┐┌┘└┼─') 

# working with English conventions 

txt = [s * inn[0] + tl + t * (out[0] - inn[0] - 1) + tr] 

for i in range(len(out) - 1): 

o0 = out[i] 

o1 = out[i + 1] 

i0 = inn[i] 

i1 = inn[i + 1] 

if i0 == i1: 

start = u' ' * i1 + l 

d0 = 1 

else: 

start = u' ' * i1 + tl 

d0 = 0 

if o0 == o1: 

end = r 

d1 = 1 

else: 

end = br 

d1 = 0 

if i0 <= o1: 

middle = t * (i0 - i1 - 1 + d0) 

middle += x * (o1 - i0 + 1 - d0 - d1) 

middle += b * (o0 - o1 - 1 + d1) 

else: 

middle = t * (i0 - i1 - 1) 

middle += h * (i0 - o1 - 1) 

middle += b * (o0 - o1 - 1) 

txt += [start + middle + end] 

txt += [s * inn[-1] + bl + b * (out[-1] - inn[-1] - 1) + br] 

if self.parent().options.convention == "French": 

txt = list(reversed(txt)) 

from sage.typeset.unicode_art import UnicodeArt 

return UnicodeArt(txt, baseline=0) 

def inner(self): 

""" 

Return the inner partition of ``self``. 

EXAMPLES:: 

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

[1, 1] 

""" 

return self[1] 

def outer(self): 

""" 

Return the outer partition of ``self``. 

EXAMPLES:: 

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

[3, 2, 1] 

""" 

return self[0] 

def column_lengths(self): 

""" 

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] 

""" 

return self.conjugate().row_lengths() 

def row_lengths(self): 

""" 

Return the row lengths of ``self``. 

EXAMPLES:: 

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

[2, 1, 1] 

""" 

skp = self 

o = skp[0] 

i = skp[1]+[0]*(len(skp[0])-len(skp[1])) 

return [x[0]-x[1] for x in zip(o,i)] 

def size(self): 

""" 

Return the size of ``self``. 

EXAMPLES:: 

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

4 

""" 

return sum(self.row_lengths()) 

def is_connected(self): 

""" 

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

""" 

return self.is_overlap(1) 

def overlap(self): 

""" 

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 

""" 

p,q = self 

if len(p) <= 1: 

from sage.rings.infinity import PlusInfinity 

return PlusInfinity() 

if len(q) == 0: 

return min(p) 

q = [q[0]] + list(q) 

return min(row_lengths_aux([p,q])) 

def is_overlap(self, n): 

r""" 

Return ``True`` if the overlap of ``self`` is at most ``n``. 

.. SEEALSO:: 

:meth:`overlap` 

EXAMPLES:: 

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

True 

""" 

return n <= self.overlap() 

def is_ribbon(self): 

r""" 

Return ``True`` if and only if ``self`` 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() 

<BLANKLINE> 

** 

* 

** 

sage: P.is_ribbon() 

True 

sage: P=SkewPartition([[4,4,3,3],[4,2,2]]) 

sage: P.pp() 

<BLANKLINE> 

** 

* 

*** 

sage: P.is_ribbon() 

True 

sage: SkewPartition([[2,2,1],[2,2,1]]).is_ribbon() 

True 

""" 

lam = self[0] 

mu = self[1] 

l_out = len(lam) 

l_in = len(mu) 

mu += [0]*(l_out-l_in) 

if l_out == 0: 

return True 

else: 

# Find the least u for which lam[u]>mu[u], if it exists 

# If it does not exist then u will equal l_out 

u = 0 

u_test = True 

while u_test: 

if u >= l_out or lam[u] > mu[u]: 

u_test = False 

else: 

u += 1 

# Find the least v strictly greater than u for which  

# lam[v] != mu[v-1]+1 

v = u + 1 

v_test = True 

while v_test: 

if v >= l_out or lam[v] != mu[v-1] + 1: 

v_test = False 

else: 

v += 1 

# Check if lam[i]==mu[i] for all i >= v 

for i in range(v, l_out): 

if lam[i] != mu[i]: 

return False 

return True 

def conjugate(self): 

""" 

Return the conjugate of the skew partition skp. 

EXAMPLES:: 

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

[3, 2, 1] / [1, 1] 

""" 

return SkewPartition([x.conjugate() for x in self]) 

def outer_corners(self): 

""" 

Return a list of the outer corners of ``self``. 

EXAMPLES:: 

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

[(0, 3), (1, 2), (2, 0)] 

""" 

return self.outer().corners() 

def inner_corners(self): 

""" 

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

""" 

inner = self.inner() 

outer = self.outer() 

if inner == []: 

if outer == []: 

return [] 

else: 

return [(0,0)] 

icorners = [(0, inner[0])] 

nn = len(inner) 

for i in range(1,nn): 

if inner[i] != inner[i-1]: 

icorners += [ (i, inner[i]) ] 

icorners += [(nn, 0)] 

return icorners 

def cell_poset(self, orientation="SE"): 

""" 

Return the Young diagram of ``self`` as a poset. The optional 

keyword variable ``orientation`` 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 the ``orientation`` 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. If ``orientation`` 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 zero-based 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] 

TESTS: 

We check that the posets are really what they should be for size 

up to `6`:: 

sage: def check_NW(n): 

....: for p in SkewPartitions(n): 

....: P = p.cell_poset(orientation="NW") 

....: for c in p.cells(): 

....: for d in p.cells(): 

....: if P.le(c, d) != (c[0] >= d[0] 

....: and c[1] >= d[1]): 

....: return False 

....: return True 

sage: all( check_NW(n) for n in range(7) ) 

True 

sage: def check_NE(n): 

....: for p in SkewPartitions(n): 

....: P = p.cell_poset(orientation="NE") 

....: for c in p.cells(): 

....: for d in p.cells(): 

....: if P.le(c, d) != (c[0] >= d[0] 

....: and c[1] <= d[1]): 

....: return False 

....: return True 

sage: all( check_NE(n) for n in range(7) ) 

True 

sage: def test_duality(n, ori1, ori2): 

....: for p in SkewPartitions(n): 

....: P = p.cell_poset(orientation=ori1) 

....: Q = p.cell_poset(orientation=ori2) 

....: for c in p.cells(): 

....: for d in p.cells(): 

....: if P.lt(c, d) != Q.lt(d, c): 

....: return False 

....: return True 

sage: all( test_duality(n, "NW", "SE") for n in range(7) ) 

True 

sage: all( test_duality(n, "NE", "SW") for n in range(7) ) 

True 

sage: all( test_duality(n, "NE", "SE") for n in range(4) ) 

False 

""" 

from sage.combinat.posets.posets import Poset 

# Getting the cover relations seems hard, so let's just compute 

# the comparison function. 

if orientation == "NW": 

def poset_le(u, v): 

return u[0] >= v[0] and u[1] >= v[1] 

elif orientation == "NE": 

def poset_le(u, v): 

return u[0] >= v[0] and u[1] <= v[1] 

elif orientation == "SE": 

def poset_le(u, v):