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 Sum(Apply(
                                                          (mj: list<integer>) => Apply(
                                                                                        (ma: list<integer>) => Fold(
                                                                                                                     Function(Apply((fl: list<integer>) => Apply((ways: list<integer>) => Apply(
                                                                                                                                                                                                 (ap: list<integer>) => Apply(
                                                                                                                                                                                                                               (cm: list<integer>) => Apply(
                                                                                                                                                                                                                                                             (sg: list<integer>) => Apply(
                                                                                                                                                                                                                                                                                           (kp: list<integer>) => [
                                                                                                                                                                                                                                                                                                                    Map(Function(Apply(
                                                                                                                                                                                                                                                                                                                                        (r: integer) => Apply((c: integer) => cm[(kp[r] - 1) *
                                                                                                                                                                                                                                                                                                                                                                                 Sum(_x) +
                                                                                                                                                                                                                                                                                                                                                                                 c], 1 +
                                                                                                                                                                                                                                                                                                                                                                                    (g - 1) %
                                                                                                                                                                                                                                                                                                                                                                                    Sum(_x)),
                                                                                                                                                                                                                                                                                                                                        1 +
                                                                                                                                                                                                                                                                                                                                        (g - 1 -
                                                                                                                                                                                                                                                                                                                                         (g - 1) %
                                                                                                                                                                                                                                                                                                                                         Sum(_x)) /
                                                                                                                                                                                                                                                                                                                                        Sum(_x),
                                                                                                                                                                                                                                                                                                                                      ), g), Range(1, Length(kp) * Sum(_x))),
                                                                                                                                                                                                                                                                                                                    Map(Function(Sum(Map(Function(Apply(
                                                                                                                                                                                                                                                                                                                                                         (e: integer) => Apply((q: integer) => ways[e], 1 +
                                                                                                                                                                                                                                                                                                                                                                                                        (ap[u] - 1) %
                                                                                                                                                                                                                                                                                                                                                                                                        Length(mj)),
                                                                                                                                                                                                                                                                                                                                                         1 +
                                                                                                                                                                                                                                                                                                                                                         (ap[u] - 1 -
                                                                                                                                                                                                                                                                                                                                                          (ap[u] - 1) %
                                                                                                                                                                                                                                                                                                                                                          Length(mj)) /
                                                                                                                                                                                                                                                                                                                                                         Length(mj),
                                                                                                                                                                                                                                                                                                                                                       ) if (Sum(Map(Function(Abs(cm[(kp[r] - 1) *
                                                                                                                                                                                                                                                                                                                                                                                    Sum(_x) +
                                                                                                                                                                                                                                                                                                                                                                                    k] -
                                                                                                                                                                                                                                                                                                                                                                                 cm[(u - 1) *
                                                                                                                                                                                                                                                                                                                                                                                    Sum(_x) +
                                                                                                                                                                                                                                                                                                                                                                                    k]), k), Range(1, Sum(_x)))) ==
                                                                                                                                                                                                                                                                                                                                                            0 if sg[kp[r]] == sg[u] else 1 == 0) else 0, u), Range(1, Length(ap)))), r), Range(1, Length(kp))),
                                                                                                                                                                                                                                                                                                                    [a[3][1] + Length(kp)],
                                                                                                                                                                                                                                                                                                                  ],
                                                                                                                                                                                                                                                                                           Filter(
                                                                                                                                                                                                                                                                                                   Range(1, Length(ap)),
                                                                                                                                                                                                                                                                                                   Function(Count(Filter(
                                                                                                                                                                                                                                                                                                                          Range(1, Length(ap)),
                                                                                                                                                                                                                                                                                                                          Function(u < s &&
                                                                                                                                                                                                                                                                                                                                   (Sum(Map(Function(Abs(cm[(s - 1) *
                                                                                                                                                                                                                                                                                                                                                            Sum(_x) +
                                                                                                                                                                                                                                                                                                                                                            k] -
                                                                                                                                                                                                                                                                                                                                                         cm[(u - 1) *
                                                                                                                                                                                                                                                                                                                                                            Sum(_x) +
                                                                                                                                                                                                                                                                                                                                                            k]), k), Range(1, Sum(_x)))) ==
                                                                                                                                                                                                                                                                                                                                    0 if sg[s] == sg[u] else 1 == 0), u),
                                                                                                                                                                                                                                                                                                                        )) ==
                                                                                                                                                                                                                                                                                                            0, s),
                                                                                                                                                                                                                                                                                                 ),
                                                                                                                                                                                                                                                                                         ),
                                                                                                                                                                                                                                                             Map(Function(Sum(Map(Function(cm[(s - 1) *
                                                                                                                                                                                                                                                                                              Sum(_x) +
                                                                                                                                                                                                                                                                                              k] *
                                                                                                                                                                                                                                                                                           (k * k +
                                                                                                                                                                                                                                                                                            1), k), Range(1, Sum(_x)))), s), Range(1, Length(ap))),
                                                                                                                                                                                                                                                           ),
                                                                                                                                                                                                                               Map(Function(Apply(
                                                                                                                                                                                                                                                   (s: integer) => Apply((c: integer) => Apply(
                                                                                                                                                                                                                                                                                                (e: integer) => Apply((q: integer) => fl[(e - 1) *
                                                                                                                                                                                                                                                                                                                                         Sum(_x) +
                                                                                                                                                                                                                                                                                                                                         c] -
                                                                                                                                                                                                                                                                                                                                      (1 if c == mj[q] else 0) +
                                                                                                                                                                                                                                                                                                                                      (1 if c == ma[q] else 0) +
                                                                                                                                                                                                                                                                                                                                      (1 if c ==
                                                                                                                                                                                                                                                                                                                                            mj[q] - ma[q] else 0), 1 +
                                                                                                                                                                                                                                                                                                                                        (ap[s] - 1) %
                                                                                                                                                                                                                                                                                                                                        Length(mj)),
                                                                                                                                                                                                                                                                                                1 +
                                                                                                                                                                                                                                                                                                (ap[s] - 1 -
                                                                                                                                                                                                                                                                                                 (ap[s] - 1) %
                                                                                                                                                                                                                                                                                                 Length(mj)) /
                                                                                                                                                                                                                                                                                                Length(mj),
                                                                                                                                                                                                                                                                                              ), 1 +
                                                                                                                                                                                                                                                                                                (g - 1) %
                                                                                                                                                                                                                                                                                                Sum(_x)),
                                                                                                                                                                                                                                                   1 +
                                                                                                                                                                                                                                                   (g - 1 -
                                                                                                                                                                                                                                                    (g - 1) %
                                                                                                                                                                                                                                                    Sum(_x)) /
                                                                                                                                                                                                                                                   Sum(_x),
                                                                                                                                                                                                                                                 ), g), Range(1, Length(ap) * Sum(_x))),
                                                                                                                                                                                                                             ),
                                                                                                                                                                                                 Filter(
                                                                                                                                                                                                         Range(1, (Length(fl) -
                                                                                                                                                                                                                   Length(fl) % Sum(_x)) /
                                                                                                                                                                                                                  Sum(_x) *
                                                                                                                                                                                                                  Length(mj)),
                                                                                                                                                                                                         Function(Apply(
                                                                                                                                                                                                                         (e: integer) => Apply((q: integer) => fl[(e - 1) *
                                                                                                                                                                                                                                                                  Sum(_x) +
                                                                                                                                                                                                                                                                  mj[q]] >=
                                                                                                                                                                                                                                                               1, 1 +
                                                                                                                                                                                                                                                                 (t - 1) %
                                                                                                                                                                                                                                                                 Length(mj)),
                                                                                                                                                                                                                         1 +
                                                                                                                                                                                                                         (t - 1 -
                                                                                                                                                                                                                          (t - 1) %
                                                                                                                                                                                                                          Length(mj)) /
                                                                                                                                                                                                                         Length(mj),
                                                                                                                                                                                                                       ), t),
                                                                                                                                                                                                       ),
                                                                                                                                                                                               ), a[2]), a[1]), a, b),
                                                                                                                     [Map(
                                                                                                                           Function(Count(Filter(Range(1, Length(_x)), Function(_x[i] == k, i))), k),
                                                                                                                           Range(1, Sum(_x)),
                                                                                                                         ), [1], [1]],
                                                                                                                     Range(1, Sum(_x) - Length(_x), 1),
                                                                                                                   ),
                                                                                        Flatten(Map(Function(Map(
                                                                                                                  Function(pa, pa),
                                                                                                                  Range(1, (pj -
                                                                                                                            pj % 2) /
                                                                                                                           2),
                                                                                                                ), pj), Range(2, Sum(_x))), 1),
                                                                                      ),
                                                          Flatten(Map(
                                                                       Function(Map(
                                                                                     Function(pj, pa),
                                                                                     Range(1, (pj -
                                                                                               pj % 2) /
                                                                                              2),
                                                                                   ), pj),
                                                                       Range(2, Sum(_x)),
                                                                     ), 1),
                                                        )[2])

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