Skip to content

IntegerCompositions ​

The compositions of nn: ordered sequences of positive parts summing to nn.

✓ checked against that system · ! checked, with disagreements (hover a chip)WikipediaComposition (combinatorics)MathWorldCompositionWikidataQ3302331OEISA011782✓A131577✓A000079✓A320487✓A166444✓A034008✓SageMathCompositions(n)mathlib4Composition n
IntegerCompositions(n)the ordered compositions of nn
Typed signatures
TypePackageApplies
(integer<0..>) -> indexed_collection<composition>combinatoricsalways

Domain: Combinatorial collections

Details
  • Count is 2n−12^{n-1} for n≥1n \ge 1
  • Unlike IntegerPartitions, order matters

Definition

Epsil, as the implementation runs it.

count(_n)

1 if _n == 0 else 2 ^ (_n - 1)

unrank(_n, _r)

[] if _n == 0 else Map(
                        Function(
                                  Join(
                                        [0],
                                        Filter(
                                                Range(1, _n - 1, 1),
                                                Function(
                                                          (2 ^ (_n - 1) - 1 - _r -
                                                           (2 ^ (_n - 1) - 1 -
                                                            _r) % 2 ^ (_n - 1 - i)) / 2 ^ (_n - 1 - i) %
                                                          2 == 1,
                                                          i,
                                                        ),
                                              ),
                                        [_n],
                                      )[j + 1] - Join(
                                                      [0],
                                                      Filter(
                                                              Range(
                                                                     1,
                                                                     _n - 1,
                                                                     1,
                                                                   ),
                                                              Function(
                                                                        (2 ^ (_n -
                                                                              1) -
                                                                         1 - _r -
                                                                         (2 ^ (_n -
                                                                               1) -
                                                                          1 - _r) %
                                                                         2 ^ (_n -
                                                                              1 -
                                                                              i)) / 2 ^
                                                                             (_n -
                                                                              1 -
                                                                              i) %
                                                                        2 == 1,
                                                                        i,
                                                                      ),
                                                            ),
                                                      [_n],
                                                    )[j],
                                  j,
                                ),
                        Range(1, Length(Join(
                                              [0],
                                              Filter(
                                                      Range(1, _n - 1, 1),
                                                      Function((2 ^ (_n - 1) - 1 -
                                                                _r - (2 ^ (_n - 1) -
                                                                    1 - _r) % 2 ^
                                                                             (_n -
                                                                              1 -
                                                                              i)) /
                                                               2 ^ (_n - 1 - i) % 2 == 1, i),
                                                    ),
                                              [_n],
                                            )) - 1, 1),
                      )

rank(_n, _x)

0 if _n == 0 else 2 ^ (_n - 1) - 1 - Fold(
                                           Function(acc + 2 ^ (_n - 1 - Fold(
                                                                              Function(acc2 + _x[t], acc2, t),
                                                                              0,
                                                                              Range(1, i, 1),
                                                                            )), acc, i),
                                           0,
                                           Range(1, Length(_x) - 1, 1),
                                         )

valid(_n, _x)

Fold(Function(acc2 + _x[t], acc2, t), 0, Range(1, Length(_x), 1)) == _n && Fold(
                                                                                 Function(ok &&
                                                                                          _x[j] >= 1, ok, j),
                                                                                 True,
                                                                                 Range(1, Length(_x), 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

Basic #

242^{4}

live ↗
InCount(IntegerCompositions(5))\mathrm{Count}(\mathrm{IntegerCompositions}(5))Out1616
About
Examples1
Checked againstmathlib4 1 agree
CrosswalkWikipediaMathWorldWikidataOEIS ×6SageMathmathlib4

Implementation

mappedmathlib4packages/oracle/src/mappings.ts

Composition n enumerated (Fintype) as block lists, in lexicographic order

See also: IntegerPartitions