- FindStat

edit this map or download as text // json

Identifier

Mp00326: Permutations —weak order rowmotion⟶ Permutations

Images

[1] => [1]

[1,2] => [2,1]

[2,1] => [1,2]

[1,2,3] => [3,2,1]

[1,3,2] => [2,3,1]

[2,1,3] => [3,1,2]

[2,3,1] => [2,1,3]

[3,1,2] => [1,3,2]

[3,2,1] => [1,2,3]

[1,2,3,4] => [4,3,2,1]

[1,2,4,3] => [3,4,2,1]

[1,3,2,4] => [4,2,3,1]

[1,3,4,2] => [3,2,4,1]

[1,4,2,3] => [2,4,3,1]

[1,4,3,2] => [2,3,4,1]

[2,1,3,4] => [4,3,1,2]

[2,1,4,3] => [3,4,1,2]

[2,3,1,4] => [4,2,1,3]

[2,3,4,1] => [3,2,1,4]

[2,4,1,3] => [2,1,4,3]

[2,4,3,1] => [2,1,3,4]

[3,1,2,4] => [4,1,3,2]

[3,1,4,2] => [1,3,2,4]

[3,2,1,4] => [4,1,2,3]

[3,2,4,1] => [2,3,1,4]

[3,4,1,2] => [3,1,4,2]

[3,4,2,1] => [3,1,2,4]

[4,1,2,3] => [1,4,3,2]

[4,1,3,2] => [1,4,2,3]

[4,2,1,3] => [1,2,4,3]

[4,2,3,1] => [2,4,1,3]

[4,3,1,2] => [1,3,4,2]

[4,3,2,1] => [1,2,3,4]

[1,2,3,4,5] => [5,4,3,2,1]

[1,2,3,5,4] => [4,5,3,2,1]

[1,2,4,3,5] => [5,3,4,2,1]

[1,2,4,5,3] => [4,3,5,2,1]

[1,2,5,3,4] => [3,5,4,2,1]

[1,2,5,4,3] => [3,4,5,2,1]

[1,3,2,4,5] => [5,4,2,3,1]

[1,3,2,5,4] => [4,5,2,3,1]

[1,3,4,2,5] => [5,3,2,4,1]

[1,3,4,5,2] => [4,3,2,5,1]

[1,3,5,2,4] => [3,2,5,4,1]

[1,3,5,4,2] => [3,2,4,5,1]

[1,4,2,3,5] => [5,2,4,3,1]

[1,4,2,5,3] => [2,4,3,5,1]

[1,4,3,2,5] => [5,2,3,4,1]

[1,4,3,5,2] => [3,4,2,5,1]

[1,4,5,2,3] => [4,2,5,3,1]

[1,4,5,3,2] => [4,2,3,5,1]

[1,5,2,3,4] => [2,5,4,3,1]

[1,5,2,4,3] => [2,5,3,4,1]

[1,5,3,2,4] => [2,3,5,4,1]

[1,5,3,4,2] => [3,5,2,4,1]

[1,5,4,2,3] => [2,4,5,3,1]

[1,5,4,3,2] => [2,3,4,5,1]

[2,1,3,4,5] => [5,4,3,1,2]

[2,1,3,5,4] => [4,5,3,1,2]

[2,1,4,3,5] => [5,3,4,1,2]

[2,1,4,5,3] => [4,3,5,1,2]

[2,1,5,3,4] => [3,5,4,1,2]

[2,1,5,4,3] => [3,4,5,1,2]

[2,3,1,4,5] => [5,4,2,1,3]

[2,3,1,5,4] => [4,5,2,1,3]

[2,3,4,1,5] => [5,3,2,1,4]

[2,3,4,5,1] => [4,3,2,1,5]

[2,3,5,1,4] => [3,2,1,5,4]

[2,3,5,4,1] => [3,2,1,4,5]

[2,4,1,3,5] => [5,2,1,4,3]

[2,4,1,5,3] => [2,1,4,3,5]

[2,4,3,1,5] => [5,2,1,3,4]

[2,4,3,5,1] => [3,4,2,1,5]

[2,4,5,1,3] => [4,2,1,5,3]

[2,4,5,3,1] => [4,2,1,3,5]

[2,5,1,3,4] => [2,1,5,4,3]

[2,5,1,4,3] => [2,1,5,3,4]

[2,5,3,1,4] => [2,1,3,5,4]

[2,5,3,4,1] => [3,5,2,1,4]

[2,5,4,1,3] => [2,1,4,5,3]

[2,5,4,3,1] => [2,1,3,4,5]

[3,1,2,4,5] => [5,4,1,3,2]

[3,1,2,5,4] => [4,5,1,3,2]

[3,1,4,2,5] => [5,1,3,2,4]

[3,1,4,5,2] => [4,1,3,2,5]

[3,1,5,2,4] => [1,3,2,5,4]

[3,1,5,4,2] => [1,3,2,4,5]

[3,2,1,4,5] => [5,4,1,2,3]

[3,2,1,5,4] => [4,5,1,2,3]

[3,2,4,1,5] => [5,2,3,1,4]

[3,2,4,5,1] => [4,2,3,1,5]

[3,2,5,1,4] => [2,3,1,5,4]

[3,2,5,4,1] => [2,3,1,4,5]

[3,4,1,2,5] => [5,3,1,4,2]

[3,4,1,5,2] => [3,1,4,2,5]

[3,4,2,1,5] => [5,3,1,2,4]

[3,4,2,5,1] => [3,2,4,1,5]

[3,4,5,1,2] => [4,3,1,5,2]

[3,4,5,2,1] => [4,3,1,2,5]

[3,5,1,2,4] => [3,1,5,4,2]

[3,5,1,4,2] => [3,1,5,2,4]

>>> Load all 5913 entries. <<<

click to show experimental identities (only identities of compositions of up to three maps are shown)

Description

Return the reversal of the permutation obtained by inverting the corresponding Laguerre heap.
This map is the composite of Mp00241invert Laguerre heap and Mp00064reverse.
Conjecturally, it is also the rowmotion on the weak order:
Any semidistributive lattice

$L$ has a canonical labeling of the edges of its Hasse diagram by its join irreducible elements (see [1] and [2]). Rowmotion on this lattice is the bijection which takes an element

$x \in L$ with a given set of down-labels to the unique element

$y \in L$ which has that set as its up-labels (see [2] and [3]). For example, if the lattice is the distributive lattice

$J(P)$ of order ideals of a finite poset

$P$ , then this reduces to ordinary rowmotion on the order ideals of

$P$ .
The weak order (a.k.a. permutohedral order) on the permutations in

$S_n$ is a semidistributive lattice. In this way, we obtain an action of rowmotion on the set of permutations in

$S_n$ .
Note that the dynamics of weak order rowmotion is poorly understood. A collection of nontrivial homomesies is described in Corollary 6.14 of [4].

References

[1] Reading, N. Noncrossing Arc Diagrams and Canonical Join Representations DOI:10.1137/140972391 arXiv:1405.6904
[2] Barnard, E. The Canonical Join Complex DOI:10.37236/7866 arXiv:1610.05137
[3] Thomas, H., Williams, N. Rowmotion in slow motion DOI:10.1112/plms.12251 arXiv:1712.10123
[4] Hopkins, S. The CDE property for skew vexillary permutations DOI:10.1016/j.jcta.2019.06.005 arXiv:1811.02404
[5] Defant, C., Williams, N. Semidistrim Lattices DOI:10.1017/fms.2023.46 arXiv:2111.08122

Properties

bijective, graded

Sage code

def invert_laguerre_heap(pi):
    n = len(pi)
    buffer = []
    heap = []
    for i in range(n):
        if not i or pi[i-1] > pi[i]:
            buffer.append(pi[i])
        else:
            heap.append(buffer[::-1])
            buffer = [pi[i]]
    if buffer:
        heap.append(buffer[::-1])
    heap = heap[::-1]
    # bubble sort pieces
    n = len(heap)
    while True:
        try:
            i = next(i for i in range(n-1) if heap[i][0] > heap[i+1][-1])
        except StopIteration:
            break
        heap[i], heap[i+1] = heap[i+1], heap[i]
    sigma = []
    while heap:
        m = []
        i = 0
        for e in heap:
            if (all(min(e) >= max(f) for f in m) or
                all(max(e) <= min(f) for f in m)):
                m.append(e)
                i += 1
            else:
                break
        heap = heap[i:]
        for e in sorted(m, key=min):
            sigma.extend(e[::-1])

    return Permutation(sigma)

def mapping(x):
    return invert_laguerre_heap(x).reverse()

# alternative, slow implementation, using the definition of rowmotion
# note that everything here is dualized (we use dual order and take joins of upper labels)

# def upper_labels(J, u):
#     for v in u.permutohedron_pred():
#         cur_min = None
#         for j in J:
#             if ((cur_min is None
#                  or cur_min.permutohedron_lequal(j))
#                 and v.permutohedron_lequal(j)
#                 and not u.permutohedron_lequal(j)):
#                 cur_min = j
#         yield cur_min
# 
# def mapping(x):
#     n = len(x)
#     bot = Permutation(range(n, 0, -1))
#     if n > 1:
#         J = [x for s in Subsets(range(n-1), n-2)
#              for x in Permutations(descents=(s, n))]
#     else:
#         J = []
#     v = bot
#     for w in upper_labels(J, x):
#         v = v.permutohedron_meet(w)
#     return v

Weight

Created

Jan 29, 2025 at 16:50 by Martin Rubey

Updated

Jan 29, 2025 at 16:50 by Martin Rubey