Skip to content

PartSizeBoundedCompositions ​

The compositions of nn into parts of size at most kk.

PartSizeBoundedCompositions(n, k)the compositions of nn into parts of size at most kk
Typed signatures
TypePackageApplies
(integer<0..>, integer<0..>) -> indexed_collection<composition>combinatoricsalways

Domain: Collections

Details

Definition

Epsil, as the implementation runs it.

count(_n, _k)

_tables[_n * 1 + 0 + 1]

unrank(_n, _k, _r)

Drop(Fold(Function(
                    Apply((pw_m: integer) => Apply((pw_c: integer) => Apply((pw_r: integer) => pw_u if pw_m == 0 else Apply(
                                                                                                                             (pw_chosen: list<integer>) => Join(
                                                                                                                                                                 [pw_m - pw_chosen[2], pw_c, pw_chosen[1]],
                                                                                                                                                                 Drop(pw_u, 3),
                                                                                                                                                                 [pw_chosen[2]],
                                                                                                                                                               ),
                                                                                                                             Fold(
                                                                                                                                   Function(pw_pick if pw_pick[2] != 0 else Apply(
                                                                                                                                                                                   (pw_k: integer) => [pw_pick[1], pw_p] if pw_pick[1] < pw_k else [pw_pick[1] - pw_k, 0],
                                                                                                                                                                                   _tables[(pw_m - pw_p) *
                                                                                                                                                                                           1 + pw_c + 1],
                                                                                                                                                                                 ) if True else pw_pick, pw_pick, pw_p),
                                                                                                                                   [pw_r, 0],
                                                                                                                                   Range(1, Min(pw_m, _k), 1),
                                                                                                                                 ),
                                                                                                                           ), pw_u[3]), pw_u[2]), pw_u[1]),
                    pw_u,
                    pw_i,
                  ), [_n, 0, _r], Range(1, _n, 1)), 3)

rank(_n, _k, _x)

Fold(
      Function(Apply((pw_r: integer) => Apply((pw_m: integer) => Apply(
                                                                        (pw_c: integer) => [pw_r +
                                                                                            Fold(
                                                                                                  Function(pw_s +
                                                                                                           (_tables[(pw_m - pw_q) *
                                                                                                                    1 + pw_c + 1] if True else 0), pw_s, pw_q),
                                                                                                  0,
                                                                                                  Range(1, pw_x - 1, 1),
                                                                                                ), pw_m - pw_x, pw_c],
                                                                        pw_a[3],
                                                                      ), pw_a[2]), pw_a[1]), pw_a, pw_x),
      [0, _n, 0],
      _x,
    )[1]

valid(_n, _k, _x)

Apply(
       (pw_end: list<integer>) => pw_end[1] == 1 && pw_end[2] == 0 && 1 != 0,
       Fold(Function(
                      Apply((pw_f: integer) => Apply((pw_m: integer) => Apply(
                                                                               (pw_c: integer) => [1, pw_m - pw_y, pw_c] if pw_f == 1 &&
                                                                                                                            pw_y >= 1 &&
                                                                                                                            pw_y <=
                                                                                                                            Min(pw_m, _k) &&
                                                                                                                            True else [0, 0, 0],
                                                                               pw_v[3],
                                                                             ), pw_v[2]), pw_v[1]),
                      pw_v,
                      pw_y,
                    ), [1, _n, 0], _x),
     )

tables(_n, _k)

Fold(
      Function(Join(
                     pw_t,
                     Fold(
                           Function(ReplaceAt(
                                               pw_row,
                                               pw_c + 1,
                                               Fold(
                                                     Function(
                                                               pw_a +
                                                               (pw_t[(pw_s -
                                                                      pw_p) * 1 +
                                                                     pw_c + 1] if True else 0),
                                                               pw_a,
                                                               pw_p,
                                                             ),
                                                     0,
                                                     Range(1, Min(pw_s, _k), 1),
                                                   ),
                                             ), pw_row, pw_c),
                           Map(Function(0, pw_z), Range(0, 1 - 1, 1)),
                           Range(0, 1 - 1, 1),
                         ),
                   ), pw_t, pw_s),
      Fold(
            Function(ReplaceAt(pw_row, pw_c + 1, 1), pw_row, pw_c),
            Map(Function(0, pw_z), Range(0, 1 - 1, 1)),
            Range(0, 1 - 1, 1),
          ),
      Range(1, _n + 1 - 1, 1),
    )

Statistics

On IntegerComposition, called as CombinatorialStat(x, "Name").

Maps

Into and out of IntegerComposition, called as CombinatorialMap(x, "Name"). Properties are the laws we state and what FindStat records.

From IntegerComposition

  • CodeWordIntegerComposition → BinaryWordInjectionGraded mapMp00094The word that writes each part i as a one followed by i - 1 zeros.
  • ComplementIntegerComposition → IntegerCompositioninvolutionBijectionGraded mapInvolutionMp00039The composition cut exactly where this one is not: its cut set complemented.
  • CompositionBouncePathIntegerComposition → DyckPathInjectionGraded mapMp00231The Dyck path that bounces off the diagonal once for each part: a run of that many ups, then as many downs.
  • CutWordIntegerComposition → BinaryWordinverseA composition of n as the binary word of length n - 1 marking where it is cut.
  • CyclicShiftIntegerComposition → IntegerCompositioninverseBijectionGraded mapMp00173Rotate the parts one place to the left: the first part moves to the end.
  • DeltaMorphismIntegerComposition → IntegerCompositionSurjectionMp00133The lengths of the maximal runs of equal parts, left to right.
  • FoataInversionsToMajorIntegerComposition → IntegerCompositionbijectioninverseBijectionGraded mapMp00315The inverse of Foata's bijection on compositions: peel off the last part, rotate the blocks of the rest back.
  • FoataMajorToInversionsIntegerComposition → IntegerCompositionbijectioninverseBijectionGraded mapMp00314Foata's bijection on the word of parts: each part is put on the end of the image so far, which is cut into blocks, and every block is rotated one place right.
  • InverseCyclicShiftIntegerComposition → IntegerCompositioninverseBijectionGraded mapMp00172Rotate the parts one place to the right: the last part moves to the front.
  • ReverseIntegerComposition → IntegerCompositioninvolutionBijectionGraded mapInvolutionMp00038The parts read backwards.
  • SortedPartitionIntegerComposition → IntegerPartitionsurjectionSurjectionGraded mapMp00040The partition a composition's parts form, sorted largest first.
  • TransposeCompositionIntegerComposition → IntegerCompositioninvolutionBijectionGraded mapInvolutionMp00041The conjugate composition: its ribbon shape transposed, the complement of the reverse.

To IntegerComposition

  • BlockSizeCompositionSetPartition → IntegerCompositionsurjectionSurjectionGraded mapMp00128The block sizes of a set partition, its blocks taken in order of their least elements.
  • BlockSizeCompositionSetComposition → IntegerCompositionsurjectionSurjectionGraded mapMp00287The block sizes of a set composition, its blocks taken in order.
  • CodeCompositionBinaryWord → IntegerCompositionInjectionGraded mapMp00178The composition whose code is the word with a 1 put in front: each 1 opens a part, of 1 plus the zeros after it.
  • DescentCompositionPermutation → IntegerCompositionsurjectionSurjectionGraded mapMp00071The composition of n cut at the descent positions.
  • IntegerCompositionBinaryWord → IntegerCompositioninverseThe composition of m + 1 a binary word of length m cuts out.
  • PeakCompositionStandardTableau → IntegerCompositionGraded mapMp00294The composition cut at the peaks: entries i that are descents after an ascent.
  • RiseCompositionDyckPath → IntegerCompositionsurjectionSurjectionGraded mapMp00102The lengths of the maximal runs of up steps, left to right.
  • RunCompositionBinaryWord → IntegerCompositionsurjectionSurjectionGraded mapMp00097The lengths of the maximal runs of equal letters, left to right.
  • TouchCompositionDyckPath → IntegerCompositionsurjectionSurjectionGraded mapMp00100The semilengths of the primitive pieces between a path's returns to the diagonal.
  • ValleyCompositionStandardTableau → IntegerCompositionGraded mapMp00295The composition cut at the valleys: entries i that are ascents after a descent.
10 more in FindStat, not implemented here
  • Mp00054ParkingFunction → IntegerCompositionSurjectionGraded mapto inverse des composition
  • Mp00057ParkingFunction → IntegerCompositionSurjectionGraded mapto touch composition
  • Mp00152LabeledGraph → IntegerCompositionSurjectionGraded mapLaplacian multiplicities
  • Mp00180IntegerComposition → SkewPartitionInjectionGraded mapto ribbon
  • Mp00181SkewPartition → IntegerCompositionSurjectionGraded maprow lengths
  • Mp00184IntegerComposition → LabeledGraphInjectionGraded mapto threshold graph
  • Mp00207StandardTableau → IntegerCompositionSurjectionGraded maphorizontal strip sizes
  • Mp00248Permutation → IntegerCompositionGraded mapDEX composition
  • Mp00319ParkingFunction → IntegerCompositionInjectionto composition
  • Mp00324LabeledGraph → IntegerCompositionGraded mapchromatic difference sequence

Enumeration

Examples

16 more kept as data, checked against the oracles
Basic #

Count(PartSizeBoundedCompositions(6,2))=13Count(PartSizeBoundedCompositions(6, 2)) = 13

live ↗
InCount(PartSizeBoundedCompositions(6,2))\mathrm{Count}(\mathrm{PartSizeBoundedCompositions}(6, 2))Out1313

The first element in enumeration order

live ↗
InPartSizeBoundedCompositions(6,2)[1]\mathrm{PartSizeBoundedCompositions}(6, 2)[1]OutIntegerComposition⁡([1,1,1,1,1,1]){\operatorname{IntegerComposition}}([1, 1, 1, 1, 1, 1])
Scope #

The first nn past 2532^{53} for parts of size at most 55: the count is the pentanacci-style recurrence, exact as a big integer

live ↗
InCount(PartSizeBoundedCompositions(56,5))\mathrm{Count}(\mathrm{PartSizeBoundedCompositions}(56, 5))Out14 816 957 550 408 63214\,816\,957\,550\,408\,632

Far past 2532^{53} the count stays exact: the coefficient of x100x^{100} in 1/(1−x−⋯−x10)1/(1 - x - \cdots - x^{10})

live ↗
InCount(PartSizeBoundedCompositions(100,10))\mathrm{Count}(\mathrm{PartSizeBoundedCompositions}(100, 10))Out606 147 434 557 459 526 483 161 067 501606\,147\,434\,557\,459\,526\,483\,161\,067\,501
About
Examples20
CrosswalkSageMath

See also: PartCountBoundedCompositions, IntegerCompositions, FibonacciCompositions, TriCompositions, TetraCompositions