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: sage.structure.sage_object.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: sage.structure.list_clone.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: sorted(s.dual_equivalence_graph().edges())
[([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: sage.structure.unique_representation.UniqueRepresentation, sage.structure.parent.Parent

The abstract parent class for PathTableau.