StandardCompositionTableauCount

Standard composition tableaux of the shape: fillings of 1 .. n with rows decreasing, the first column increasing, and the triple rule.

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

StandardCompositionTableauCount(composition)Standard composition tableaux of the shape: fillings of 1 .. n with rows decreasing, the first column increasing, and the triple rule.

Typed signatures

Type	Package	Applies
(composition) -> number	combinatorics	always

Domain: Composition statistics

Details

• Defined over IntegerComposition as an expression in _x, evaluated by compute-engine — the definition IS the implementation.
• Takes a IntegerComposition 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.
• Luoto, Mykytiuk and van Willigenburg, An introduction to quasisymmetric Schur functions (Definition 4.2.6).

Definition

Epsil, as the implementation runs it.

on IntegerComposition, over _x

1 if Length(_x) < 1 else Apply(
                                (radices: list<integer>) => 1 if Sum(_x) == 0 else Last(Fold(
                                                                                              Function(Join(
                                                                                                             a,
                                                                                                             [Apply(
                                                                                                                     (placed: list<integer>) => Sum(Map(Function(a[b - radices[j] +
                                                                                                                                                                   1] if placed[j] >= 1 &&
                                                                                                                                                                        ((1 == 1 if j == 1 else placed[j - 1] ==
                                                                                                                                                                                                _x[j - 1]) if _x[j] - placed[j] ==
                                                                                                                                                                                                     0 else Count(Filter(Range(1, Length(_x)), Function(i < j &&
                                                                                                                                                                                                                                                       _x[i] - placed[i] ==
                                                                                                                                                                                                                                                       _x[j] - placed[j], i))) ==
                                                                                                                                                                                                           0) else 0, j), Range(1, Length(_x)))),
                                                                                                                     Map(Function((b %
                                                                                                                                   radices[j + 1] -
                                                                                                                                   b % radices[j]) /
                                                                                                                                  radices[j], j), Range(1, Length(_x))),
                                                                                                                   )],
                                                                                                           ), a, b),
                                                                                              [1],
                                                                                              Range(1, Last(radices) - 1, 1),
                                                                                            )),
                                Fold(Function(
                                               Join(a, [Last(a) * (b + 1)]),
                                               a,
                                               b,
                                             ), [1], _x),
                              )

Examples

Basic #

the composition $[2,1,3,1,1]$

live ↗

In$\mathrm{StandardCompositionTableauCount}({\operatorname{IntegerComposition}}([2, 1, 3, 1, 1]))$Out$3$

Properties #

FindStat's value for [1]

live ↗

In$\mathrm{CombinatorialStat}({\operatorname{IntegerComposition}}([1]), \text{StandardCompositionTableauCount})$Out$1$

Known value · FindStat St000816

FindStat's value for [2]

live ↗

In$\mathrm{CombinatorialStat}({\operatorname{IntegerComposition}}([2]), \text{StandardCompositionTableauCount})$Out$1$

Known value · FindStat St000816

FindStat's value for [3]

live ↗

In$\mathrm{CombinatorialStat}({\operatorname{IntegerComposition}}([3]), \text{StandardCompositionTableauCount})$Out$1$

Known value · FindStat St000816

About

Examples	4
Crosswalk	FindStat