Macaulay2 » Documentation
Packages » SchurComplexes :: straightenTableau
next | previous | forward | backward | up | index | toc

straightenTableau -- Straightening law for Z/2Z-graded tableau

Synopsis

Description

This function takes a $\mathbb{Z}/2\mathbb{Z}$-graded Young tableau and expresses it as a linear combination of standard tableau. Positive entries in the tableaux correspond to even elements, and negative entries correspond to odd elements.

The user inputs the Young tableau T in the form of a hash table, and a partition of the same shape as T, in the form of a list. The key $(i,j)$ in the hash table of T corresponds to the box of T in column $i$ and row $j$. The values are the entries of the boxes of T.

The output is a hash table with keys representing standard tableaux and values representing the coefficients in the linear combination.

i1 : T = new HashTable from {(1,1) => -3, (1,2) => -2, (1,3) => -2, (2,1) => 1, (2,2) => 2, (2,3) => 3, (3,1) => -1, (3,2) => -1};
 
i2 : lambda = {3,3,2};
 
i3 : straightenTableau(T,lambda)

o3 = HashTable{HashTable{(1, 1) => -3} => 1 }
                         (1, 2) => -2
                         (1, 3) => -2
                         (2, 1) => -1
                         (2, 2) => -1
                         (2, 3) => 3
                         (3, 1) => 1
                         (3, 2) => 2
               HashTable{(1, 1) => -3} => -1
                         (1, 2) => -2
                         (1, 3) => -2
                         (2, 1) => -1
                         (2, 2) => -1
                         (2, 3) => 2
                         (3, 1) => 1
                         (3, 2) => 3
               HashTable{(1, 1) => -3} => 1
                         (1, 2) => -2
                         (1, 3) => -2
                         (2, 1) => -1
                         (2, 2) => -1
                         (2, 3) => 1
                         (3, 1) => 2
                         (3, 2) => 3

o3 : HashTable

We compute a second example.

i4 : T = new HashTable from {(1,1) => -1, (1,2) => -2, (1,3) => 3, (2,1) => 2, (2,2) => 1, (2,3) => -3};
 
i5 : lambda = {2,2,2};
 
i6 : straightenTableau(T,lambda)

o6 = HashTable{HashTable{(1, 1) => -3} => 1 }
                         (1, 2) => -2
                         (1, 3) => 2
                         (2, 1) => -1
                         (2, 2) => 1
                         (2, 3) => 3
               HashTable{(1, 1) => -3} => -1
                         (1, 2) => -2
                         (1, 3) => 1
                         (2, 1) => -1
                         (2, 2) => 2
                         (2, 3) => 3
               HashTable{(1, 1) => -3} => 1
                         (1, 2) => -1
                         (1, 3) => 2
                         (2, 1) => -2
                         (2, 2) => 1
                         (2, 3) => 3
               HashTable{(1, 1) => -3} => -1
                         (1, 2) => -1
                         (1, 3) => 1
                         (2, 1) => -2
                         (2, 2) => 2
                         (2, 3) => 3
               HashTable{(1, 1) => -3} => 1
                         (1, 2) => -2
                         (1, 3) => -1
                         (2, 1) => 1
                         (2, 2) => 2
                         (2, 3) => 3

o6 : HashTable

See also

For the programmer

The object straightenTableau is a function closure.