YoungLatticeCoveringRelationCount

The covering relations of Young's lattice among the partitions contained in this one: the sum of their corners.

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

YoungLatticeCoveringRelationCount(partition)The covering relations of Young's lattice among the partitions contained in this one: the corners, summed over those partitions. The table carries, for each last row size, the number of choices and the corners they have so far.

Typed signatures

Type	Package	Applies
(integer_partition) -> number	combinatorics	always

Domain: Partition statistics

Details

• Defined over IntegerPartition as an expression in _x, evaluated by compute-engine — the definition IS the implementation.
• Takes a IntegerPartition 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.

Definition

Epsil, as the implementation runs it.

on IntegerPartition, over _x

0 if Length(_x) < 1 else Apply(
                                (t: list<list<integer>>) => Max(Sum(t[2]) +
                                                                Sum(Map(
                                                                         Function(t[1][i], i),
                                                                         Range(
                                                                                2,
                                                                                Max(_x) + 1,
                                                                              ),
                                                                       )), 0),
                                Fold(Function([
                                                Map(
                                                     Function(Sum(Map(
                                                                       Function(a[1][k], k),
                                                                       Range(
                                                                              i,
                                                                              Max(_x) +
                                                                              1,
                                                                            ),
                                                                     )) if i >= 1 &&
                                                                          i <= b +
                                                                               1 else 0, i),
                                                     Range(1, Max(_x) + 1),
                                                   ),
                                                Map(
                                                     Function(
                                                               Sum(Map(
                                                                        Function(a[2][k] +
                                                                                 (a[1][k] if k > i else 0), k),
                                                                        Range(
                                                                               i,
                                                                               Max(_x) +
                                                                               1,
                                                                             ),
                                                                      )) if i <=
                                                                           b + 1 else 0,
                                                               i,
                                                             ),
                                                     Range(1, Max(_x) + 1),
                                                   ),
                                              ], a, b), [
                                                         Map(
                                                              Function(1, i),
                                                              Range(1, Max(_x) +
                                                                       1),
                                                            ),
                                                         Map(
                                                              Function(0, i),
                                                              Range(1, Max(_x) +
                                                                       1),
                                                            ),
                                                       ], Rest(_x)),
                              )

Examples

Basic #

the partition $4 + 2 + 1$ of $7$

live ↗

In$\mathrm{YoungLatticeCoveringRelationCount}({\operatorname{IntegerPartition}}([4, 2, 1]))$Out$31$

the partition $3 + 3 + 1$ of $7$

live ↗

In$\mathrm{YoungLatticeCoveringRelationCount}({\operatorname{IntegerPartition}}([3, 3, 1]))$Out$24$

Properties #

FindStat's value for [1]

live ↗

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

Known value · FindStat St001360

FindStat's value for [2]

live ↗

In$\mathrm{CombinatorialStat}({\operatorname{IntegerPartition}}([2]), \text{YoungLatticeCoveringRelationCount})$Out$2$

Known value · FindStat St001360

FindStat's value for [3]

live ↗

In$\mathrm{CombinatorialStat}({\operatorname{IntegerPartition}}([3]), \text{YoungLatticeCoveringRelationCount})$Out$3$

Known value · FindStat St001360

About

Examples	5
Crosswalk	FindStat