- FindStat

edit this map or download as text // json

Identifier

Mp00322: Integer partitions —Loehr-Warrington⟶ Integer partitions

Images

[] => []

[1] => [1]

[2] => [1,1]

[1,1] => [2]

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

[2,1] => [3]

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

[4] => [1,1,1,1]

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

[2,2] => [4]

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

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

[5] => [1,1,1,1,1]

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

[3,2] => [5]

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

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

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

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

[6] => [1,1,1,1,1,1]

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

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

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

[3,3] => [6]

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

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

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

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

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

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

[7] => [1,1,1,1,1,1,1]

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

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

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

[4,3] => [7]

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

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

[3,3,1] => [6,1]

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

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

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

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

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

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

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

[8] => [1,1,1,1,1,1,1,1]

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

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

[6,1,1] => [3,1,1,1,1,1]

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

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

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

[4,4] => [8]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

[9] => [1,1,1,1,1,1,1,1,1]

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

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

[7,1,1] => [3,1,1,1,1,1,1]

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

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

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

[5,4] => [9]

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

[5,2,2] => [6,1,1,1]

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

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

[4,4,1] => [8,1]

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

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

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

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

[4,1,1,1,1,1] => [4,4,1]

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

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

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

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

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

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

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

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

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

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

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

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

[10] => [1,1,1,1,1,1,1,1,1,1]

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

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

[8,1,1] => [3,1,1,1,1,1,1,1]

>>> Load all 1288 entries. <<<

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

Description

Return a partition whose diagonal inversion number is the length of the preimage.

References

[1] Loehr, N. A., Warrington, G. S. A continuous family of partition statistics equidistributed with length MathSciNet:2475023

Properties

bijective, graded

Sage code

from collections import defaultdict
def Bdy(mu, r, s, n):
    """
    Return the corresponding 0-1 sequence (in French notation).

    EXAMPLES::

        sage: mu = Partition([12,12,10,8,7,4,1,1,1])
        sage: w = Bdy(mu, 3, 2, 5); w
        [1, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0]
        sage: Partitions().from_zero_one([1-e for e in w])
        [12, 12, 10, 8, 7, 4, 1, 1, 1]
    """
    mu = Partition(mu)
    D = list(mu.to_dyck_word())
    rn_deficit = r*n - len(D) // 2
    sn_deficit = s*n - len(D) // 2
    if rn_deficit > 0:
        D = D + [0] * rn_deficit
    elif rn_deficit < 0:
        assert all(e == 0 for e in D[rn_deficit:])
        D = D[:rn_deficit]
    if sn_deficit > 0:
        D = [1] * sn_deficit + D
    elif sn_deficit < 0:
        assert all(e == 1 for e in D[:-sn_deficit])
        D = D[-sn_deficit:]
    return D

def VBdy(mu, r, s, n):
    """
    EXAMPLES::

        sage: mu = Partition([12,12,10,8,7,4,1,1,1])
        sage: VBdy(mu, 3, 2, 5)
        [(0, 0),
         (0, 1),
         (1, 1),
         (1, 2),
         (1, 3),
         (1, 4),
         (2, 4),
         (3, 4),
         (4, 4),
         (4, 5),
         (5, 5),
         (6, 5),
         (7, 5),
         (7, 6),
         (8, 6),
         (8, 7),
         (9, 7),
         (10, 7),
         (10, 8),
         (11, 8),
         (12, 8),
         (12, 9),
         (12, 10),
         (13, 10),
         (14, 10),
         (15, 10)]
    """
    D = Bdy(mu, r, s, n)
    l = [(0, 0)]
    for e in D:
        x, y = l[-1]
        if e == 0:
            l.append((x + 1, y))
        else:
            l.append((x, y + 1))
    return l

def eulerian_tour(mu, r, s, n):
    """
    EXAMPLES::

        sage: mu = Partition([12,12,10,8,7,4,1,1,1])
        sage: eulerian_tour(mu, 3, 2, 5)
        [0, 3, 1, 4, 7, 10, 8, 6, 4, 7, 5, 3, 1, 4, 2, 5, 3, 1, 4, 2, 0, 3, 6, 4, 2, 0]
    """
    return [r*y - s*x for x, y in VBdy(mu, r, s, n)]

def from_eulerian_tour(e, r, s, n):
    """
    Return the partition corresponding to the Eulerian tour.

    EXAMPLES::

        sage: mu = Partition([12,12,10,8,7,4,1,1,1])
        sage: e = eulerian_tour(mu, 3, 2, 5); e
        [0, 3, 1, 4, 7, 10, 8, 6, 4, 7, 5, 3, 1, 4, 2, 5, 3, 1, 4, 2, 0, 3, 6, 4, 2, 0]
        sage: from_eulerian_tour(e, 3, 2, 5)
        [12, 12, 10, 8, 7, 4, 1, 1, 1]
    """
    w = [1 if e[i] - e[i-1] == r else 0 for i in range(1, len(e))]
    return Partitions().from_zero_one([1 - e for e in w])

def phi_a(mu, r, s, n):
    """

    EXAMPLES::

        sage: mu = Partition([12,10,10,8,7,6,1,1,1])
        sage: dict(phi_a(mu, 3, 2, 5))
        {3: (1, 1, 0, 0),
         1: (0, 0, 0),
         4: (1, 0, 1, 1, 0),
         7: (1, 1),
         10: (1,),
         8: (0,),
         6: (0, 1),
         2: (0, 0, 0),
         0: (0, 0),
         5: (1, 0)}
    """
    e = eulerian_tour(mu, r, s, n)
    d = defaultdict(tuple)
    for i in range(1, len(e)):
        v = e[i]
        d[v] += (ZZ(v - e[i-1] == r),)
    return d

def from_phi_a(ws, r, s, n):
    """
    EXAMPLES::

        sage: mu = Partition([12,10,10,8,7,6,1,1,1])
        sage: ws = phi_a(mu, 3, 2, 5)
        sage: from_phi_a(ws, 3, 2, 5) == mu
        True
    """
    last = {v: len(w)-1 for v, w in ws.items()}
    e = [0]
    u = 0
    while True:
        w = ws[u]
        i = last[u]
        if i < 0:
            assert all(i < 0 for i in last.values())
            break
        d = w[i]
        last[u] -= 1
        u = u - r if d == 1 else u + s
        e.append(u)
    return from_eulerian_tour(e[::-1], r, s, n)

def distances(T):
    """
    Return a dictionary mapping vertices to distances from the 0
    vertex.

    EXAMPLES::

        sage: distances([(3, 1), (4, 2), (0, 3), (1, 4), (7, 5), (8, 6), (4, 7), (10, 8), (7, 10)])
        {0: 0, 3: 1, 1: 2, 4: 3, 7: 4, 10: 5, 2: 4, 5: 5, 8: 6, 6: 7}
    """
    d = dict()
    d[0] = 0
    while len(d) <= len(T):
        for u, v in T:
            if u in d:
                d[v] = d[u] + 1
    return d

def involution(mu, r, s, n):
    """
    EXAMPLES::

        sage: mu = Partition([12,12,10,8,7,4,1,1,1])
        sage: involution(mu, 3, 2, 5)
        [12, 10, 10, 8, 7, 6, 1, 1, 1]

        sage: m=20; all((mu == involution(involution(mu, 1, 1, 2*m), 1, 1, 2*m)) for mu in Partitions(m))
        True
        sage: m=20; all((mu == involution(involution(mu, 1, 2, 2*m), 1, 2, 2*m)) for mu in Partitions(m))
        True
    """
    ws = phi_a(mu, r, s, n)
    T = [(v-r, v) if w[0] == 1 else (v+s, v)
         for v, w in ws.items() if v]
    d = distances(T)

    for v in ws:
        if (v and v + s in ws and v - r in ws
            and d[v+s] == d[v-r] == d[v] - 1):
            # green vertices
            ws[v] = ws[v][::-1]
        else:
            # blue and red vertices
            w = ws[v]
            ws[v] = (w[0],) + w[1:][::-1]

    return from_phi_a(ws, r, s, n)

@cached_function
def critical(n):
    if n == 0:
        return [0, oo]
    return sorted(set(critical(n-1) + [ZZ(a)/(n-a) for a in range(1, n)]))

def mapping(mu):
    """
    Return a partition whode diagonal inversion number is the length of mu.

    EXAMPLES::

        sage: s = findstat(378); s
        St000378: The diagonal inversion number of an integer partition.
        sage: all(len(mu) == s(mapping(mu)) for n in range(10) for mu in Partitions(n))
        True
    """
    n = mu.size()
    for q in critical(n):
        if not q: continue
        if q > 1: break
        r = q.numer()
        s = q.denom()
        mu = involution(mu, r, s, ceil((r+s)/(r*s)*n))
    return mu

Weight

Created

Mar 19, 2024 at 14:36 by Martin Rubey

Updated

Aug 05, 2024 at 22:55 by Martin Rubey