SingletonRefinementCount

The chains of single splits (a part into two) from this partition down to all ones.

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

SingletonRefinementCount(partition)The chains of single splits (a part into two) from this partition down to all ones.

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

1 if Length(_x) < 1 else 1 if Sum(_x) < 2 else Apply(
                                                      (sp: list<integer>) => Apply(
                                                                                    (levels: list<integer>) => Sum(Map(
                                                                                                                        Function(levels[Length(levels) / 2 +
                                                                                                                                        i], i),
                                                                                                                        Range(1, Length(levels) / 2),
                                                                                                                      )),
                                                                                    Fold(
                                                                                          Function(Apply((half: integer) => Apply(
                                                                                                                                   (to: list<integer>) => Apply(
                                                                                                                                                                 (wt: list<integer>) => Apply((next: list<integer>) => Join(next, Map(Function(0 if u == 0 else Sum(Map(Function(wt[e] if to[e] == u else 0, e), Range(1, half * Length(sp)))), u), next)), Unique(to)),
                                                                                                                                                                 Map(Function(a[half +
                                                                                                                                                                                1 +
                                                                                                                                                                                (e - 1 -
                                                                                                                                                                                 (e - 1) %
                                                                                                                                                                                 Length(sp)) /
                                                                                                                                                                                Length(sp)], e), Range(1, half * Length(sp))),
                                                                                                                                                               ),
                                                                                                                                   Map(Function(Apply(
                                                                                                                                                       (sj: integer) => Apply(
                                                                                                                                                                               (sa: integer) => a[1 +
                                                                                                                                                                                                  (e - 1 -
                                                                                                                                                                                                   (e - 1) %
                                                                                                                                                                                                   Length(sp)) /
                                                                                                                                                                                                  Length(sp)] -
                                                                                                                                                                                                ((Sum(_x) + 1) ^
                                                                                                                                                                                                 sj -
                                                                                                                                                                                                 ((Sum(_x) + 1) ^
                                                                                                                                                                                                  sa +
                                                                                                                                                                                                  (Sum(_x) + 1) ^
                                                                                                                                                                                                  (sj - sa))) if 2sa <= sj &&
                                                                                                                                                                                                    (a[1 +
                                                                                                                                                                                                       (e - 1 -
                                                                                                                                                                                                        (e - 1) %
                                                                                                                                                                                                        Length(sp)) /
                                                                                                                                                                                                       Length(sp)] -
                                                                                                                                                                                                     a[1 +
                                                                                                                                                                                                       (e - 1 -
                                                                                                                                                                                                        (e - 1) %
                                                                                                                                                                                                        Length(sp)) /
                                                                                                                                                                                                       Length(sp)] %
                                                                                                                                                                                                     (Sum(_x) + 1) ^
                                                                                                                                                                                                     sj) /
                                                                                                                                                                                                    (Sum(_x) + 1) ^
                                                                                                                                                                                                    sj %
                                                                                                                                                                                                    (Sum(_x) + 1) >=
                                                                                                                                                                                                    1 else 0,
                                                                                                                                                                               1 +
                                                                                                                                                                               sp[1 +
                                                                                                                                                                                  (e - 1) %
                                                                                                                                                                                  Length(sp)] %
                                                                                                                                                                               (Sum(_x) - 1),
                                                                                                                                                                             ),
                                                                                                                                                       2 +
                                                                                                                                                       (sp[1 +
                                                                                                                                                           (e - 1) %
                                                                                                                                                           Length(sp)] -
                                                                                                                                                        sp[1 +
                                                                                                                                                           (e - 1) %
                                                                                                                                                           Length(sp)] %
                                                                                                                                                        (Sum(_x) - 1)) /
                                                                                                                                                       (Sum(_x) - 1),
                                                                                                                                                     ), e), Range(1, half * Length(sp))),
                                                                                                                                 ), Length(a) / 2), a, b),
                                                                                          [
                                                                                            Sum(Map(Function((Sum(_x) + 1) ^
                                                                                                             _x[i], i), Range(1, Length(_x)))),
                                                                                            1,
                                                                                          ],
                                                                                          Range(1, Sum(_x) - Length(_x), 1),
                                                                                        ),
                                                                                  ),
                                                      Flatten(Map(
                                                                   Function(Map(
                                                                                 Function((pj - 2) *
                                                                                          (Sum(_x) - 1) +
                                                                                          (pa - 1), pa),
                                                                                 Range(1, (pj -
                                                                                           pj % 2) /
                                                                                          2),
                                                                               ), pj),
                                                                   Range(
                                                                          2,
                                                                          Sum(_x),
                                                                        ),
                                                                 )),
                                                    )

Examples

Basic #

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

live ↗

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

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

live ↗

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

Properties #

FindStat's value for [1]

live ↗

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

Known value · FindStat St000913

FindStat's value for [2]

live ↗

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

Known value · FindStat St000913

FindStat's value for [3]

live ↗

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

Known value · FindStat St000913

About

Examples	5
Crosswalk	FindStat