schubmult.combinatorics.plactic¶

Plactic: skew semistandard tableaux with the plactic (Knuth) crystal structure, stored as a grid with an optional inner (skew) shape of holes.

Plactic Objects¶

class Plactic(GridPrint, CrystalGraph)

A (skew) semistandard Young tableau stored as a grid, with the gl_n plactic crystal structure (Knuth relations). inner_shape (a partition of leading holes per row) makes it a skew tableau; construct directly from a grid or via classmethods like Plactic.yamanouchi.

evacuation¶

def evacuation(n)

Schutzenberger evacuation within the alphabet 1..n: insert the complemented row word n + 1 - a.

iter_boxes¶

@property
def iter_boxes()

Filled cells in row-word order (bottom row to top, left to right).

up_jdt_slide¶

def up_jdt_slide(row, col)

Perform an upward jeu de taquin slide starting from the given (row, col) position (0-indexed). Returns a new Plactic tableau.

down_jdt_slide¶

def down_jdt_slide(row, col)

Perform a jeu de taquin slide starting from the given (row, col) position (0-indexed). Returns a new Plactic tableau.

iter_outer_corners¶

@property
def iter_outer_corners()

Empty cells that can receive a reverse JDT slide.

iter_inner_corners¶

@property
def iter_inner_corners()

Holes of the inner shape that can receive a forward JDT slide.

init¶

def __init__(word=(), inner_shape=None)

Build from rows (tuple of tuples), a prebuilt grid, or empty; inner_shape gives the skew holes. The grid is stored with one extra border row and column so outer corners always exist.

shiftup¶

def shiftup(k)

Return a new Plactic with all entries increased by k.

all_ss_tableaux¶

@classmethod
def all_ss_tableaux(cls, shape, max_entry, inner_shape=None)

Generate all semistandard tableaux of given shape (or skew shape) with entries <= max_entry.

Arguments:

shape - Sequence of row lengths (outer shape)
max_entry - Maximum entry value
inner_shape - Optional sequence of left offsets per row (for skew shapes). If provided, positions [row][0:inner_shape[row]] are marked as 0.

Returns:

Set of Plactic instances representing all valid semistandard tableaux

row_word¶

@property
def row_word()

Return the row-reading word as a flat tuple.

column_word¶

@property
def column_word()

Entries read column by column, each column bottom to top.

transpose¶

def transpose()

Return the transpose of this Plactic tableau.

invert¶

def invert()

Return a Plactic whose entries are remapped so that standard (increasing) insertion order applies. If reverse_semistandard is True we negate entries (so larger original becomes smaller).

mul¶

def __mul__(other)

Plactic product: insert entries of other in row-reading order (top-to-bottom, left-to-right) into a copy of self.

shape¶

@property
def shape()

Row lengths (filled cells per nonempty row).

skew_shape¶

@property
def skew_shape()

Return the skew shape as a tuple of (row_length, left_offset) pairs.

from_word¶

@classmethod
def from_word(cls, word)

RS insertion tableau of a word.

rs_insert¶

def rs_insert(*letters)

Insert one or more letters in sequence (row-insertion) and return a new Plactic.

raising_operator¶

def raising_operator(i)

Crystal raising operator e_i on the Plactic tableau (delegates to RCGraph).

lowering_operator¶

def lowering_operator(i)

Crystal lowering operator f_i on the Plactic tableau (delegates to RCGraph).

crystal_weight¶

@property
def crystal_weight()

Return the crystal weight of this tableau (delegated to RCGraph).

crystal_length¶

def crystal_length()

Return the length/number of rows used for the crystal

yamanouchi¶

@classmethod
def yamanouchi(cls, shape)

Return the Yamanouchi (highest-weight) tableau of the given shape.

is_increasing¶

@property
def is_increasing()

Check if the tableau is strictly increasing in rows and columns.

rectify¶

def rectify()

Jeu de taquin rectification of a skew tableau to a straight shape.

superstandard¶

@classmethod
def superstandard(cls, shape)

The standard tableau of the given shape filled 1, 2, ... row by row, left to right.

is_semistandard¶

@property
def is_semistandard()

Rows weakly increasing and columns strictly increasing (skipping holes).

reverse_rsk¶

def reverse_rsk(recording_tableau)

Inverse RSK (row-insertion) for the pair (P,Q) where self is P and recording_tableau is the standard recording tableau Q of the same shape.

Returns the original word as a list of integers (in insertion order).

rsk_insert¶

@classmethod
def rsk_insert(cls, *letters)

Perform ordinary RSK (row insertion) on the given sequence of letters, starting from this Plactic as the initial P-tableau. Returns a pair (P_tableau, Q_tableau) where both are Plactic instances and Q is the standard recording tableau with entries 1..m (in insertion order).

Usage: P, Q = Plactic().rsk_insert(3,1,2,1) or P, Q = Plactic().rsk_insert([3,1,2,1])

reverse_rectify_to_outer¶

def reverse_rectify_to_outer(outer_shape)

Deterministic reverse-rectification to a given outer shape outer_shape.

Given a (straight) tableau self of shape lambda, produce a skew tableau (represented as a Plactic whose rows may contain 0's for inner cells) of outer shape outer_shape whose rectification is self.

outer_shape: iterable of nonnegative ints giving the desired outer row lengths (mu_0 >= mu_1 >= ...).

Algorithm (deterministic):

Let mu be the set of cells (r,c) with 0 <= r < len(mu) and 0 <= c < mu[r].
While the current set of occupied cells (from the working tableau) is a strict subset of mu:
choose an outer corner cell (r,c) in mu\current_cells (no cell of mu to its right or below). Choose the maximal such (r,c) (deterministic).
create a hole at (r,c) (extend rows/cols as needed, set that cell to 0), then perform an upward jeu-de-taquin slide from (r,c) using up_jdt_slide to move the hole inward.
adopt the resulting tableau and continue.
Return the resulting Plactic (with zeros marking inner/removed cells).

Notes:

Raises ValueError if outer_shape does not dominate the current shape (i.e. mu must contain the current occupied cells).
Raises RuntimeError if no suitable outer corner can be found or if an up_jdt_slide fails (this indicates the requested outer shape is not attainable by reverse-rectification).