HaglundStevensInversionCount

The pairs of a cell's entry and a smaller entry lying below the cell's inversion path, over all cells.

✓ checked against that system · ! checked, with disagreements (hover a chip)FindStatSt000059via StandardTableau✓↗

HaglundStevensInversionCount(tableau)The pairs of a cell's entry and a smaller entry lying below the cell's inversion path, over all cells.

Typed signatures

Type	Package	Applies
(standard_tableau) -> number	combinatorics	always

Domain: Tableau statistics

Details

• Defined over StandardTableau as an expression in _x, evaluated by compute-engine — the definition IS the implementation.
• Takes a StandardTableau and nothing else — it reads values against their positions, or walks the orbits, so it needs the bijection. Applying it to a bare list is a type error, not a wrong answer.
• FindStat's St000059, Haglund and Stevens's inversion number. The inversion path of a cell leaves it up when the entry above is larger than the entry to the left, else left, until it reaches the first column (and then runs straight up) or the first row; the cells below the path in a row are those from the path's column on. A path has fewer than n steps and stays put once it ends.

Definition

Epsil, as the implementation runs it.

on StandardTableau, over _x

0 if Length(_x) < 1 else Apply((reading: list<integer>) => Apply(
                                                                  (lengths: list<integer>) => Apply(
                                                                                                     (rowIds: list<integer>) => Apply(
                                                                                                                                       (columnIds: list<integer>) => Max(Sum(Map(Function(Fold(
                                                                                                                                                                                                Function([1, a[2] +
                                                                                                                                                                                                             Max(Sum(Map(Function(1 if rowIds[v] < rowIds[a[1]] &&
                                                                                                                                                                                                                                       reading[v] < reading[u] else 0, v), Range(1, Length(reading), 1))), 0)] if columnIds[a[1]] == 1 else a if rowIds[a[1]] == 1 else [a[1] -
                                                                                                                                                                                                                                                                         lengths[rowIds[a[1]] - 1], a[2] +
                                                                                                                                                                                                                                                                           Max(Sum(Map(Function(1 if rowIds[v] ==
                                                                                                                                                                                                                                                                                                     rowIds[a[1]] - 1 &&
                                                                                                                                                                                                                                                                                                     columnIds[v] >= columnIds[a[1]] &&
                                                                                                                                                                                                                                                                                                     reading[v] < reading[u] else 0, v), Range(1, Length(reading), 1))), 0)] if reading[a[1] -
                                                                                                                                                                                                                                                                                        lengths[rowIds[a[1]] - 1]] >
                                                                                                                                                                                                                                                                                reading[a[1] - 1] else [a[1] - 1, a[2]], a, b),
                                                                                                                                                                                                [u, 0],
                                                                                                                                                                                                Range(1, Length(reading), 1),
                                                                                                                                                                                              )[2], u), Range(1, Length(reading), 1))), 0),
                                                                                                                                       Flatten(Map(Function(Range(1, lengths[i], 1), i), Range(1, Length(_x)))),
                                                                                                                                     ),
                                                                                                     Flatten(Map(
                                                                                                                  Function(Map(Function(i, j), Range(1, lengths[i], 1)), i),
                                                                                                                  Range(1, Length(_x)),
                                                                                                                )),
                                                                                                   ),
                                                                  Map(
                                                                       Function(Length(r), r),
                                                                       _x,
                                                                     ),
                                                                ), Flatten(_x))

Examples

Basic #

the standard tableau $[[1,2,4],[3,6],[5]]$

live ↗

In$\mathrm{HaglundStevensInversionCount}({\operatorname{StandardTableau}}([[1, 2, 4], [3, 6], [5]]))$Out$9$

Properties #

FindStat's value for [[1]]

live ↗

In$\mathrm{CombinatorialStat}({\operatorname{StandardTableau}}([[1]]), \text{HaglundStevensInversionCount})$Out$0$

Known value · FindStat St000059

FindStat's value for [[1,2]]

live ↗

In$\mathrm{CombinatorialStat}({\operatorname{StandardTableau}}([[1, 2]]), \text{HaglundStevensInversionCount})$Out$0$

Known value · FindStat St000059

FindStat's value for [[1,2,3]]

live ↗

In$\mathrm{CombinatorialStat}({\operatorname{StandardTableau}}([[1, 2, 3]]), \text{HaglundStevensInversionCount})$Out$0$

Known value · FindStat St000059

About

Examples	4
Crosswalk	FindStat