Path Tableaux#

This is an abstract base class for using local rules to construct rectification and the action of the cactus group [Wes2017].

This is a construction of the Henriques-Kamnitzer construction of the action of the cactus group on tensor powers of a crystal. This is also a generalisation of the Fomin growth rules, which are a version of the operations on standard tableaux which were previously constructed using jeu de taquin.

The basic operations are rectification, evacuation and promotion. Rectification of standard skew tableaux agrees with the rectification by jeu de taquin as does evacuation. Promotion agrees with promotion by jeu de taquin on rectangular tableaux but in general they are different.

REFERENCES:

[Wes2017]

AUTHORS:

Bruce Westbury (2018): initial version

class sage.combinat.path_tableaux.path_tableau.CylindricalDiagram(T)#

Bases: SageObject

Cylindrical growth diagrams.

EXAMPLES:

sage: t = path_tableaux.DyckPath([0,1,2,3,2,1,0])
sage: path_tableaux.CylindricalDiagram(t)
[0, 1, 2, 3, 2, 1, 0]
[ , 0, 1, 2, 1, 0, 1, 0]
[ ,  , 0, 1, 0, 1, 2, 1, 0]
[ ,  ,  , 0, 1, 2, 3, 2, 1, 0]
[ ,  ,  ,  , 0, 1, 2, 1, 0, 1, 0]
[ ,  ,  ,  ,  , 0, 1, 0, 1, 2, 1, 0]
[ ,  ,  ,  ,  ,  , 0, 1, 2, 3, 2, 1, 0]

pp()#

A pretty print utility method.

EXAMPLES:

sage: t = path_tableaux.DyckPath([0,1,2,3,2,1,0])
sage: path_tableaux.CylindricalDiagram(t).pp()
0 1 2 3 2 1 0
  0 1 2 1 0 1 0
    0 1 0 1 2 1 0
      0 1 2 3 2 1 0
        0 1 2 1 0 1 0
          0 1 0 1 2 1 0
            0 1 2 3 2 1 0

sage: t = path_tableaux.FriezePattern([1,3,4,5,1])
sage: path_tableaux.CylindricalDiagram(t).pp()
  0   1   3   4   5   1   0
      0   1 5/3 7/3 2/3   1   0
          0   1   2   1   3   1   0
              0   1   1   4 5/3   1   0
                  0   1   5 7/3   2   1   0
                      0   1 2/3   1   1   1   0
                          0   1   3   4   5   1   0

class sage.combinat.path_tableaux.path_tableau.PathTableau#

Bases: ClonableArray

This is the abstract base class for a path tableau.

cactus(i, j)#

Return the action of the generator \(s_{i,j}\) of the cactus group on self.

INPUT:

i – a positive integer j – a positive integer weakly greater than i

EXAMPLES:

sage: t = path_tableaux.DyckPath([0,1,2,3,2,1,0])
sage: t.cactus(1,5)
[0, 1, 0, 1, 2, 1, 0]

sage: t.cactus(1,6)
[0, 1, 2, 1, 0, 1, 0]

sage: t.cactus(1,7) == t.evacuation()
True
sage: t.cactus(1,7).cactus(1,6) == t.promotion()
True

commutor(other, verbose=False)#

Return the commutor of self with other.

If verbose=True then the function will print the rectangle.

EXAMPLES:

sage: t1 = path_tableaux.DyckPath([0,1,2,3,2,1,0])
sage: t2 = path_tableaux.DyckPath([0,1,2,1,0])
sage: t1.commutor(t2)
([0, 1, 2, 1, 0], [0, 1, 2, 3, 2, 1, 0])
sage: t1.commutor(t2,verbose=True)
[0, 1, 2, 1, 0]
[1, 2, 3, 2, 1]
[2, 3, 4, 3, 2]
[3, 4, 5, 4, 3]
[2, 3, 4, 3, 2]
[1, 2, 3, 2, 1]
[0, 1, 2, 1, 0]
([0, 1, 2, 1, 0], [0, 1, 2, 3, 2, 1, 0])

dual_equivalence_graph()#

Return the graph with vertices the orbit of self and edges given by the action of the cactus group generators.

In most implementations the generators \(s_{i,i+1}\) will act as the identity operators. The usual dual equivalence graphs are given by replacing the label \(i,i+2\) by \(i\) and removing edges with other labels.

EXAMPLES:

sage: s = path_tableaux.DyckPath([0,1,2,3,2,3,2,1,0])
sage: s.dual_equivalence_graph().adjacency_matrix()
[0 1 1 1 0 1 0 1 1 0 0 0 0 0]
[1 0 1 1 1 1 1 0 1 0 0 1 1 0]
[1 1 0 1 1 1 0 1 0 1 1 1 0 0]
[1 1 1 0 1 0 1 1 1 1 0 1 1 0]
[0 1 1 1 0 0 1 0 0 1 1 0 1 1]
[1 1 1 0 0 0 1 1 1 1 1 0 1 0]
[0 1 0 1 1 1 0 1 0 1 1 1 0 1]
[1 0 1 1 0 1 1 0 1 1 1 1 1 0]
[1 1 0 1 0 1 0 1 0 1 0 1 1 0]
[0 0 1 1 1 1 1 1 1 0 0 1 1 1]
[0 0 1 0 1 1 1 1 0 0 0 1 1 1]
[0 1 1 1 0 0 1 1 1 1 1 0 1 1]
[0 1 0 1 1 1 0 1 1 1 1 1 0 1]
[0 0 0 0 1 0 1 0 0 1 1 1 1 0]
sage: s = path_tableaux.DyckPath([0,1,2,3,2,1,0])
sage: s.dual_equivalence_graph().edges(sort=True)
[([0, 1, 0, 1, 0, 1, 0], [0, 1, 0, 1, 2, 1, 0], '4,7'),
 ([0, 1, 0, 1, 0, 1, 0], [0, 1, 2, 1, 0, 1, 0], '2,5'),
 ([0, 1, 0, 1, 0, 1, 0], [0, 1, 2, 1, 2, 1, 0], '2,7'),
 ([0, 1, 0, 1, 2, 1, 0], [0, 1, 2, 1, 0, 1, 0], '2,6'),
 ([0, 1, 0, 1, 2, 1, 0], [0, 1, 2, 1, 2, 1, 0], '1,4'),
 ([0, 1, 0, 1, 2, 1, 0], [0, 1, 2, 3, 2, 1, 0], '2,7'),
 ([0, 1, 2, 1, 0, 1, 0], [0, 1, 2, 1, 2, 1, 0], '4,7'),
 ([0, 1, 2, 1, 0, 1, 0], [0, 1, 2, 3, 2, 1, 0], '3,7'),
 ([0, 1, 2, 1, 2, 1, 0], [0, 1, 2, 3, 2, 1, 0], '3,6')]

evacuation()#

Return the evacuation operator applied to self.

EXAMPLES:

sage: t = path_tableaux.DyckPath([0,1,2,3,2,1,0])
sage: t.evacuation()
[0, 1, 2, 3, 2, 1, 0]

final_shape()#

Return the final shape of self.

EXAMPLES:

sage: t = path_tableaux.DyckPath([0,1,2,3,2,1,0])
sage: t.final_shape()
0

initial_shape()#

Return the initial shape of self.

EXAMPLES:

sage: t = path_tableaux.DyckPath([0,1,2,3,2,1,0])
sage: t.initial_shape()
0

local_rule(i)#

This is the abstract local rule defined in any coboundary category.

This has input a list of objects. This method first takes the list of objects of length three consisting of the \((i-1)\)-st, \(i\)-th and \((i+1)\)-term and applies the rule. It then replaces the \(i\)-th object by the object returned by the rule.

EXAMPLES:

sage: t = path_tableaux.DyckPath([0,1,2,3,2,1,0])
sage: t.local_rule(3)
[0, 1, 2, 1, 2, 1, 0]

orbit()#

Return the orbit of self under the action of the cactus group.

EXAMPLES:

sage: t = path_tableaux.DyckPath([0,1,2,3,2,1,0])
sage: t.orbit()
{[0, 1, 0, 1, 0, 1, 0],
 [0, 1, 0, 1, 2, 1, 0],
 [0, 1, 2, 1, 0, 1, 0],
 [0, 1, 2, 1, 2, 1, 0],
 [0, 1, 2, 3, 2, 1, 0]}

promotion()#

Return the promotion operator applied to self.

EXAMPLES:

sage: t = path_tableaux.DyckPath([0,1,2,3,2,1,0])
sage: t.promotion()
[0, 1, 2, 1, 0, 1, 0]

size()#

Return the size or length of self.

EXAMPLES:

sage: t = path_tableaux.DyckPath([0,1,2,3,2,1,0])
sage: t.size()
7

class sage.combinat.path_tableaux.path_tableau.PathTableaux#

Bases: UniqueRepresentation, Parent

The abstract parent class for PathTableau.