Functions for investigating permutations -- basic functions for permutations

This package provides significantly expanded functionality for studying permutations in Macaulay2.

[HPW22] Aldo Conca, Emanuela De Negri, and Elisa Gorla, Radical generic initial ideals, Vietnam J. Math.50(2022), no.3, 807–827.
[HPW22] Zachary Hamaker, Oliver Pechenik, and Anna Weigandt, Gröbner geometry of Schubert polynomials through ice, Advances in Mathematics 398 (2022): 108228.
[Kle23] Patricia Klein, Diagonal degenerations of matrix Schubert varieties, Algebraic Combinatorics 6 (2023) no. 4, 1073-1094.
[KW21] Patricia Klein and Anna Weigandt, Bumpless pipe dreams encode Gröbner geometry of Schubert polynomials, arxiv preprint 2108.08370.
[KM05] Allen Knutson and Ezra Miller, Gröbner geometry of Schubert polynomials, Annals of Mathematics (2005): 1245-1318.
[KMY09] Allen Knutson, Ezra Miller, and Alexander Yong Gröbner geometry of vertex decompositions and of flagged tableaux, J. Reine Angew. Math.630(2009), 1-31.
[Wei17] Anna Weigandt, Prism tableaux for alternating sign matrix varieties, arXiv preprint 1708.07236.

Given a permutation as a list of integers, one can check if it is indeed a permutation, what its descent set is, what its inverse is, and the Coxeter length of the permutation.

i1 : v = {2,1,6,3,5,4};

i2 : isPerm v --checks if v is indeed a permutation

o2 = true

i3 : lastDescent v

o3 = 5

i4 : firstDescent v

o4 = 1

i5 : inverseOf v

o5 = {2, 1, 4, 6, 5, 3}

o5 : List

This package also allows one to quickly compute certain combinatorial polynomials associated to a permutation, such as the (double) Schubert polynomial and the Grothendieck polynomial.

i6 : u = {3,1,4,2}

o6 = {3, 1, 4, 2}

o6 : List

i7 : schubertPolynomial u

      2      2
o7 = x x  + x x
      1 2    1 3

o7 : QQ[x ..x ]
         1   4

i8 : doubleSchubertPolynomial u

      2      2      2                          2    2                      
o8 = x x  + x x  - x y  - x x y  - x x y  + x y  - x y  - x x y  - x x y  +
      1 2    1 3    1 1    1 2 1    1 3 1    1 1    1 2    1 2 2    1 3 2  
     ------------------------------------------------------------------------
                                  2        2      2
     2x y y  + x y y  + x y y  - y y  + x y  - y y
       1 1 2    2 1 2    3 1 2    1 2    1 2    1 2

o8 : QQ[x ..x , y ..y ]
         1   4   1   4

i9 : grothendieckPolynomial u

        2        2      2
o9 = - x x x  + x x  + x x
        1 2 3    1 2    1 3

o9 : QQ[x ..x ]
         1   4

Moreover, this package contains functionality for checking whether a permutation avoids a set of patterns. For instance, isCDG checks whether a permutation is CDG; isVexillary checks whether a permutation is 2143-avoiding; and isCartwrightSturmfels checks whether a permutation is Cartwright-Sturmfels.

i10 : w = {1,2,3,9,8,4,5,6,7};

i11 : isPatternAvoiding(w,{4,1,2,3})

o11 = true

i12 : isVexillary w

o12 = true

i13 : isCartwrightSturmfels w

o13 = false

i14 : isCDG w

o14 = true

Finally, this package contains functionality for studying both reduced and nonreduced pipe dreams of a permutation.

i15 : decompose antiDiagInit u

o15 = {monomialIdeal (z   , z   , z   ), monomialIdeal (z   , z   , z   )}
                       1,1   1,2   2,2                   1,1   1,2   3,1

o15 : List

i16 : pipeDreams u

o16 = {++//, ++//}
       /+//  ////
       ////  +///
       ////  ////

o16 : List

i17 : pipeDreamsNonReduced u

o17 = {++//, ++//, ++//}
       /+//  /+//  ////
       ////  +///  +///
       ////  ////  ////

o17 : List

Functions for studying permutations

isPerm(List) -- whether a list is a permutation in 1-line notation
permToMatrix(List) -- converts a permutation in 1-line notation into a permutation matrix
lastDescent(List) -- finds the location of the last descent of a permutation
firstDescent(List) -- finds the location of the first descent of a permutation
permLength(List) -- to find the length of a permutation in 1-line notation.
inverseOf(List) -- to return the inverse of a permutation in 1-line notation.
longestPerm(ZZ) -- to return the longest permutation of length n
toOneLineNotation(List,ZZ) -- rewrites a transposition in 1-line notation
composePerms(List,List) -- computes the composition of two permutations
isPatternAvoiding(List,List) -- whether a permutation avoids certain patterns, e.g. $2143$-avoiding or $312$- and $231$-avoiding
isVexillary(List) -- whether a permutation is vexillary, i.e. 2143-avoiding
avoidsAllPatterns(List,List) -- whether a permutation avoids all of the given patterns
isCartwrightSturmfels(List) -- whether a permutation is Cartwright-Sturmfels
isCDG(List) -- whether a permutation is CDG
rajcode(List) -- finds the Rajchgot code of a permutation
rajIndex(List) -- finds the Rajchgot index of a permutation
grothendieckPolynomial(List) -- computes the Grothendieck polynomial of a permutation
schubertPolynomial(List) -- computes the Schubert polynomial of a permutation
doubleSchubertPolynomial(List) -- computes the double Schubert polynomial of a permutation
pipeDreams(List) -- computes the set of reduced pipe dreams corresponding to a permutation
pipeDreamsNonReduced(List) -- computes the set of all pipe dreams corresponding to a permutation