PartitionsInBox

The integer partitions fitting in an $a \times b$ box: at most $a$ parts, each at most $b$. Count $\binom{a+b}{a}$.

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

PartitionsInBox(a, b)partitions with at most $a$ parts, each at most $b$

Typed signatures

Type	Package	Applies
(integer<0..>, integer<0..>) -> indexed_collection<integer_partition>	combinatorics	always

Domain: Collections

Definition

Epsil, as the implementation runs it.

count(_a, _b)

Binomial(_a + _b, _a)

unrank(_a, _b, _r)

Apply(
       (pb_digits: list<integer>) => Filter(
                                             Map(
                                                  Function(
                                                            _b - (pb_digits[m +
                                                                            1] +
                                                                  1) + m,
                                                            m,
                                                          ),
                                                  Range(1, _a, 1),
                                                ),
                                             Function(_t > 0, _t),
                                           ),
       Apply((pb_st_init: list<integer>) => Fold(
                                                  (pb_st: list<integer>, pb_i) => Apply(
                                                                                         (pb_st_next: list<integer>) => pb_st_next,
                                                                                         Apply((pb_left: integer) => Apply(
                                                                                                                            (pb_found: integer) => ReplaceAt(ReplaceAt(pb_st, 1, pb_left -
                                                                                                                                                                                 _tables[pb_found *
                                                                                                                                                                                         (_a + 1) + pb_i + 1]), pb_i + 1, pb_found),
                                                                                                                            Fold(
                                                                                                                                  Function(pb_c if _tables[pb_c *
                                                                                                                                                           (_a + 1) + pb_i + 1] <=
                                                                                                                                                   pb_left else pb_best, pb_best, pb_c),
                                                                                                                                  pb_i - 1,
                                                                                                                                  Range(
                                                                                                                                         pb_i - 1,
                                                                                                                                         (_a + _b if pb_i == _a else pb_st[pb_i + 2]) -
                                                                                                                                         1,
                                                                                                                                         1,
                                                                                                                                       ),
                                                                                                                                ),
                                                                                                                          ), pb_st[1]),
                                                                                       ),
                                                  pb_st_init,
                                                  Range(_a, 1, -1),
                                                ), Join(
                                                        [_r],
                                                        Map(
                                                             Function(0, pb_z),
                                                             Range(1, _a, 1),
                                                           ),
                                                      )),
     )

rank(_a, _b, _x)

Fold(Function(acc + _tables[(_b - (_x[j] if j <= Length(_x) else 0) + j - 1) *
                            (_a + 1) + j + 1], acc, j), 0, Range(1, _a, 1))

valid(_a, _b, _x)

Length(_x) <= _a && Fold(Function(okv && _x[jv] >= 1 &&
                                         _x[jv] <= _b &&
                                         (_x[jv] <= _x[jv - 1] if jv > 1 else True), okv, jv), True, Range(
                                                                  1,
                                                                  Length(_x),
                                                                  1,
                                                                ))

tables(_a, _b)

Fold(
      Function(
                Join(
                      pc_t,
                      Fold(
                            Function(
                                      ReplaceAt(
                                                 pc_row,
                                                 pc_c + 1,
                                                 1 if pc_c == 0 else pc_t[(pc_s -
                                                                           1) *
                                                                          (_a +
                                                                           1) +
                                                                          (pc_c -
                                                                           1) + 1] +
                                                                     pc_t[(pc_s -
                                                                           1) *
                                                                          (_a +
                                                                           1) +
                                                                          pc_c +
                                                                          1],
                                               ),
                                      pc_row,
                                      pc_c,
                                    ),
                            Map(Function(0, pc_z), Range(0, _a + 1 - 1, 1)),
                            Range(0, _a + 1 - 1, 1),
                          ),
                    ),
                pc_t,
                pc_s,
              ),
      Fold(
            Function(
                      ReplaceAt(pc_row, pc_c + 1, 1 if pc_c == 0 else 0),
                      pc_row,
                      pc_c,
                    ),
            Map(Function(0, pc_z), Range(0, _a + 1 - 1, 1)),
            Range(0, _a + 1 - 1, 1),
          ),
      Range(1, Max(_a + _b, 1) - 1, 1),
    )

Statistics

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

• AddableCellsSt000318Cells that can be added to the diagram and leave a partition: one more than the distinct parts.
• AftSt001214The size minus the larger of the largest part and the number of parts.
• AlladiWeightSt000477The last part times the product over consecutive parts of the gap less 1.
• ArmOfFirstCellThe arm of cell (1,1): the first part minus one.
• BerkovichGarvanRankSt001383The sum of a checkerboard filling of the diagram, +1 on cells whose coordinates sum to an even number and -1 on the others.
• BorderSkewStandardTableauCountSt001387Standard tableaux of the skew shape that adds a cell to every column of the diagram: the size factorial over the factorials of the cells added to each row (the size less the largest part, then the gaps between consecutive parts).
• BraceletCountSt001603The colorings of a polygon with these color multiplicities, up to rotation and reflection: the necklaces and the colorings fixed by the reflections, over twice the size.
• BulgarianSolitaireOrbitSizeSt001914The partitions that Bulgarian solitaire (remove the first column, insert it as a row) visits from this one, itself included.
• BulgarianSolitairePreimageCountSt001913The partitions of the same size that Bulgarian solitaire (remove the first column, insert it as a row) sends to this one: the distinct part sizes of at least the number of parts less one.
• BulgarianSolitairePreperiodSt001912The steps of Bulgarian solitaire before this partition reaches the cycle it ends in.
• CartanDeterminantSt001571The determinant of the matrix of the minimums of the distinct parts: the least distinct part times the gaps between consecutive distinct parts.
• CellsOutsideDurfeeSquareSt001382Cells of the diagram outside its Durfee square.
• CellsOutsideFirstHookSt001175Cells in neither the first row nor the first column: the size minus the hook length of cell (1,1).
• CellsOutsideFirstRowSt001176Cells of the diagram below the first row: the size minus the largest part.
• CellsOutsideLargestStaircaseSt001384Cells of the diagram outside the largest staircase it contains.
• CellsWithEqualArmAndLegSt001924Cells whose arm and leg are equal.
• CellsWithZeroLegAndOddArmSt000149Cells with leg 0 and an odd arm.
• CentralizerSizeSt000184The size of the centralizer of a permutation with these cycle lengths: the product of the parts times the product of the factorials of the multiplicities.
• CoarseningCountSt000346The partitions that coarsen this one, whose parts subdivide to give its. Itself included.
• CohookLengthProductSt001378The product of the cohook lengths i + j - 1 of the cells.
• CompleteHomogeneousSymmetricFunctionAtOneSt001562The complete homogeneous symmetric function indexed by the partition, in as many variables as it has parts, all set to 1: the product of the multiset coefficients of the number of parts and each part.
• ConjugacyClassSizeSt000182The number of permutations of the same cycle type: n! over the product of the cycle sizes and the factorials of the multiplicities.
• ConjugateDistinctPartsSt000159Distinct part sizes of the conjugate.
• ConjugateOddPartsSt000992Odd parts of the conjugate — equivalently, the distinct part sizes of λ.
• ContainingRectangleShortSideSt000533The shorter side of the smallest rectangle that contains the diagram: the smaller of the largest part and the number of parts.
• ContainingSquareSideSt000784The side of the smallest square that contains the diagram: the larger of the largest part and the number of parts.
• ContentSumSt000509The sum of the contents j - i of the cells.
• CornerMajorIndexSt000770The sum, over the corners, of the step number along the boundary path from the bottom left: (number of parts - i) + the i-th part.
• CornersSt000159Corner cells — parts strictly larger than the next part (the last part always counts).
• CouplesAreForeverGrundyValueSt000752The Grundy value of the game that splits a part above 2 into two parts: the nim-sum of the values of the parts, each the least value missing from the nim-sums over its splits.
• CrankSt000474The Andrews-Garvan crank: the largest part when λ has no 1s, else (parts larger than the number of 1s) minus (the number of 1s).
• CubedStandardTableauCountSt000901The cube of the number of standard tableaux.
• CubeRootCountSt001364The permutations whose cube is a fixed permutation of this cycle type: the product over part sizes d, with a parts of size d, of the number of ways to take the cube root of each part of size d alone or of three together as a cycle of length 3d.
• CyclicSievingPolynomialDegreeSt001918(1 - 1/largest part) times the least common multiple of the parts: the degree of the cyclic sieving polynomial of a permutation with these cycle lengths.
• DiagonalArmSumSt000319St000320The sum of the arms of the cells on the main diagonal.
• DiagonalHookLengthProductSt000870The product of the hook lengths of the cells on the main diagonal.
• DiagonalInversionDefectSt000377Cells whose arm minus leg is neither 0 nor 1.
• DiagonalInversionsSt000378Cells whose arm minus leg is 0 or 1.
• DistinctEvenPartsSt001092Distinct even part sizes.
• DistinctEvenSubsetSumsSt000547Distinct nonzero even sums of sub-multisets of the parts.
• DistinctMultiplicitiesSt000897How many different multiplicities the part sizes have.
• DistinctOddPartsBelowLargestEvenPartSt001588Distinct odd part sizes smaller than the largest even part.
• DistinctOddSubsetSumsSt000549Distinct odd sums of sub-multisets of the parts.
• DistinctPartsSt000159How many distinct part sizes occur.
• DistinctPartsEqualToMultiplicitySt001940Distinct part sizes equal to their multiplicity.
• DistinctRepeatedPartsSt000257Distinct part sizes that occur at least twice.
• DistinctSubsetSumsSt000548Distinct sums of non-empty sub-multisets of the parts.
• DominatedPartitionCountSt000321The partitions of the same size that this one dominates (partial sums of the parts at least those of the other), itself included.
• DurfeeSquareSt000183The side of the Durfee square: the largest d with at least d parts of size at least d.
• DysonRankSt000145Largest part minus number of parts.
• EdgeOrbitCountSt001982Orbits of the complete graph's edges under a permutation with these cycle lengths: the sum of half the parts rounded down, plus the sum of gcd(part, part) over pairs.
• ElementarySymmetricFunctionAtOneSt001561The elementary symmetric function indexed by the partition, in as many variables as it has parts, all set to 1: the product of the binomial coefficients of the number of parts and each part.
• EvenOddCrankSt000997The largest even part minus the number of odd parts.
• EvenPartsSt000142Parts that are even.
• ExponensConsonantiaeSt001128The least common multiple of the parts over their greatest common divisor.
• FirstRowHookLengthSumSt000867The sum of the hook lengths in the first row: the size plus the binomial of the largest part and 2.
• FlooredHalfMultiplicitySumSt000150The sum, over part sizes, of half the multiplicity rounded down.
• GiniIndexSt001541The size plus 1 choose 2, less the sum over the columns of the column length plus 1 choose 2.
• GreatestCommonDivisorOfPartsSt000667The greatest common divisor of the parts.
• HalfLargestEvenPartSt001587Half the largest even part; 0 if there is none.
• HalfPerimeterHalf the perimeter of the bounding rectangle of the Young diagram: largest part plus number of parts.
• HalfSumOfEvenPartsSt001252Half the sum of the even parts.
• HookLengthOfFirstCellSt000459The hook length of cell (1,1): the largest part plus the number of parts, less one.
• HookLengthOfLastDiagonalCellSt000460The hook length of the last cell on the main diagonal: that of cell (d,d) for Durfee side d.
• HookLengthSquareSumSt001943The sum of the squares of all hook lengths.
• HookProductSt000179The product of all hook lengths — the denominator in the hook-length formula.
• HurwitzNumberSt001763Hurwitz's number for the partition: (n + c - 2)! n^(c-3) times the product of p^p / (p-1)! over its c parts p, n being its size.
• InterlacingPartitionCountSt001814The number of partitions that interlace this one: the product over the parts of the gap to the next part (0 after the last) plus 1.
• InvariantGraphCountSt000514The simple graphs on the points that a permutation of this cycle type maps to themselves: 2 to the number of edge orbits.
• InvariantOrientedCycleCountSt000510The cyclic permutations that a permutation of this cycle type fixes under conjugation: none unless the parts are all equal to some d, in which case totient(d) d^(m-1) (m-1)! for m parts.
• InvariantSubsetCountSt000511Subsets of the points left invariant by a permutation with these cycle lengths: each cycle is in or out, 2 to the number of cycles.
• InvariantThreeElementSubsetCountSt000512Invariant 3-element subsets: three fixed points, a fixed point and a 2-cycle, or a 3-cycle.
• InvariantTwoElementSubsetCountSt000513Invariant 2-element subsets: a pair of fixed points or a 2-cycle.
• IsSelfConjugateSt0011221 when λ equals its conjugate, 0 otherwise.
• KrewerasNumberSt000517The number of noncrossing set partitions whose block sizes are the parts: the size factorial over the factorial of size + 1 - length and the factorials of the multiplicities.
• LagrangeInversionCoefficientSt001967The coefficient of the monomial in the compositional-inverse series: n (n + 1) ... (n + length - 2) over the factorials of the multiplicities.
• LargestEvenPartSt000995The largest even part; 0 if there is none.
• LargestMissingPartSt001392The largest integer below the largest part that is not a part; 0 if every smaller integer is.
• LargestMultiplicitySt001933The largest multiplicity of a part.
• LargestPartSt000147The largest part.
• LargestRepeatedPartSt000143The largest part that occurs at least twice; 0 if the parts are distinct.
• LargestShiftedPartSt000384The largest part after adding i - 1 to the i-th part.
• LargestStaircaseSideSt000783St001432The side of the largest staircase (k, k-1, ..., 1) inside the diagram.
• LeastCommonMultipleOfPartsSt000668The least common multiple of the parts.
• LegOfFirstCellThe leg of cell (1,1): the number of parts minus one.
• LengthCrankSt000146The number of parts when λ has no 1s, else (parts larger than the number of 1s) minus (the number of 1s).
• LogarithmicDerivativeCoefficientSt001968The coefficient of the monomial in the logarithmic derivative of 1 - c_1 x - c_2 x^2/2! - ..., times a factorial: the set partitions with these block sizes, times (length - 1)! for arranging the blocks in a cycle.
• LowerCoverCountInDominanceOrderSt000480The partitions of the same size that this one covers in dominance order: the upper covers of its conjugate.
• MaximalRectangleHalfPerimeterSt000380Half the perimeter of the rectangle inside the diagram that has the greatest perimeter.
• MaximalRookPlacementCountSt001659The ways to place as many non-attacking rooks as possible on the Ferrers board of the diagram.
• MinimalSubpartitionSizeDifferenceSt000835The smallest difference in size between the two halves of a split of the parts into two sub-multisets.
• MonotoneHurwitzNumberSt001934The monotone factorizations of genus zero of a permutation of this cycle type into transpositions: the product of the Catalan numbers C(p - 1) over the parts p.
• MultinomialOfPartsSt000048The multinomial coefficient of the size over the parts: the size factorial over the product of the factorials of the parts.
• MultipartitionCountSt000933Tuples of partitions whose sizes are the parts: the product of the partition numbers of the parts.
• MultiplicityFactorialProductSt000706The product of the factorials of the multiplicities of the parts.
• MultiplicityOfLargestPartSt000993How many parts equal the largest.
• MultiplicityOfSmallestPartSt000160How many parts equal the smallest.
• NecklaceCountSt001605The colorings of a cycle with these color multiplicities, up to rotation: the size's divisors d of the greatest common divisor of the parts, each contributing totient(d) multinomials, over the size.
• NonDominatingSubmultisetCountSt001714The distinct sub-multisets of the parts that, read as partitions, do not dominate their own conjugate.
• OddPartsSt000148Parts that are odd.
• OddPartsBelowLargestEvenPartSt001586Odd parts smaller than the largest even part.
• OrderedRefinementCountSt000935The partitions whose parts cut, in order, into consecutive blocks summing to the parts of this one.
• PairsOfDistinctPartsSt000175Pairs of parts that differ in size: the degree of the polynomial counting semistandard tableaux of the stretched shape.
• PairwiseGreatestCommonDivisorSumSt001961The sum of the greatest common divisors of all pairs of parts.
• PairwiseProductSumSt000567The sum of the products of all pairs of parts.
• PartCountSt000010The number of parts.
• PartFactorialProductSt000707The product of the factorials of the parts.
• PartitionSizeSt000228The sum of the parts.
• PartProductSt000708The product of the parts.
• PartRangeSt000225The largest part minus the smallest.
• PartRearrangementCountSt000278Distinct rearrangements of the parts, the compositions that sort to this partition: the number of parts factorial over the factorials of the multiplicities.
• PartsAtLeastTwoSt001280Parts of size at least 2.
• PartsEqualOneSt000475Parts equal to 1.
• PartsEqualToMultiplicitySt001939Parts equal to their own multiplicity.
• PartsEqualToNextPartSt001091Parts whose next smaller part has the same size: the number of parts less the distinct parts.
• PartsEqualTwoSt001657Parts equal to 2.
• PartsExceedingOnesSt000473Parts larger than the number of parts equal to 1.
• PartsNotCongruentToOneModuloThreeSt001251Parts that are not congruent to 1 modulo 3.
• PartsNotCongruentToTwoModuloThreeSt001247Parts that are not congruent to 2 modulo 3.
• PartsNotCongruentToZeroModuloThreeSt001250Parts that are not divisible by 3.
• PartSquareProductSt001129The product of the squares of the parts.
• PartSquareSumSt001127The sum of the squares of the parts.
• PlancherelCountSt000284The square of the number of standard tableaux: the permutations whose Robinson-Schensted shape is this partition.
• PowerSumSymmetricFunctionAtOneSt001563The power-sum symmetric function indexed by the partition, in as many variables as it has parts, all set to 1: the number of parts to its own power.
• RefinementCountSt000345The partitions that refine this one, whose parts subdivide to give theirs. Itself included.
• RemovableHorizontalDominoesSt000256Parts from which 2 can be subtracted and leave a partition: rows ending in a removable horizontal domino.
• RimHooksRemovedToThreeCoreSt000697The 3-rim hooks removed to reach the 3-core.
• RimHooksRemovedToTwoCoreSt000698The 2-rim hooks removed to reach the 2-core: the size less the core's, over 2, the core read off the abacus.
• RookPlacementCountSt000532The rook placements, of any number of rooks, on the Ferrers board of the diagram.
• RowCellPairsSt000566Pairs of cells in the same row: the sum over parts of the binomial coefficient of the part and 2.
• RowRemovalGrundyValueSt001055The Grundy value of the game that removes cells from the end of a row while the diagram stays a partition: staircase nim, the nim-sum of the differences of consecutive parts at odd positions.
• SameLengthSubpartitionCountSt001389The partitions with as many parts contained in this one.
• SeaweedAlgebraDimensionSt001262The dimension of the maximal parabolic seaweed algebra: half the sum of the squares of the parts and of the size.
• SecondAlladiWeightSt000478Half the last part (rounded up if odd), times the product over consecutive parts of half the gap less 1 for each even one of the two.
• SemistandardTableauCountWithEntriesUpToFourSt000712Semistandard tableaux of the shape with entries at most 4.
• SemistandardTableauCountWithEntriesUpToLengthSt000704Semistandard tableaux of the shape with entries at most the number of parts.
• SemistandardTableauCountWithEntriesUpToSizeSt000705Semistandard tableaux of the shape with entries at most the size of the partition.
• SemistandardTableauCountWithEntriesUpToThreeSt000715Semistandard tableaux of the shape with entries at most 3.
• SemistandardTableauCountWithEntriesUpToTwoSt000714Semistandard tableaux of the shape with entries at most 2: the product of 2 + j - i over the cells, over the hook product.
• SetPartitionsWithBlockSizesCountSt000049The number of set partitions whose block sizes are the parts: the size factorial over the product of the factorials of the parts and of the multiplicities.
• ShiftedStandardTableauCountSt001593Standard tableaux of the shifted shape: the multinomial of the parts times, over pairs of parts, the difference over the sum. 0 when two parts are equal.
• ShorterSideRookPlacementCountSt000531The ways to place as many non-attacking rooks as the shorter side of the Ferrers board's bounding rectangle has cells, 0 when they do not fit.
• SingletonPartsSt001484Parts that occur exactly once.
• SingletonRefinementCountSt000913The chains of single splits (a part into two) from this partition down to all ones.
• SmallestMissingPartSt000759The smallest positive integer that is not a part.
• SmallestNonRepeatedIntegerSt001568The smallest positive integer that is not a part at least twice.
• SmirnovWordCountSt001097The words with each letter used this many times and no letter twice in a row: the Carlitz-Scoville-Vaughan sum over the numbers of runs of each letter, taken as a binomial convolution over the parts.
• StandardTableauCountSt000003The number of standard Young tableaux of the shape: the size factorial over the hook product.
• StandardTableauCountWithMajorIndexCongruentToOneModuloSizeSt001440The standard Young tableaux whose major index leaves remainder 1 on division by the size of the shape (never, when the size is 1).
• StarTranspositionFactorizationCountSt001936Minimal transitive factorizations of a permutation of this cycle type into star transpositions: the product of the parts times (n + 1) ... (n + length - 2).
• SubpartitionCountSt000108The partitions contained in this one.
• SubsetGreatestCommonDivisorSumSt001985The sum, over the non-empty subsets of the parts, of their greatest common divisor: the sum over d of phi(d) times one less than 2 to the number of parts divisible by d.
• SumOfEvenPartsSt001248The sum of the even parts.
• SumOfHookLengthsSt000869The total of all hook lengths.
• SumOfOddPartsSt001249The sum of the odd parts.
• SumOfPartsAtLeastTwoSt001279The sum of the parts that are at least 2.
• SymmetricDiagonalHooksSt001525Cells on the main diagonal whose arm and leg are equal.
• SymplecticDimensionRankThreeSt000716The dimension of the irreducible representation of Sp(6) with this highest weight; 0 if the partition has more than 3 parts.
• SymplecticDimensionRankTwoSt000713The dimension of the irreducible representation of Sp(4) with this highest weight; 0 if the partition has more than 2 parts.
• TransitiveMonotoneFactorizationCountSt001938Transitive monotone factorizations of genus zero of a permutation of this cycle type, into n + length - 2 transpositions.
• TwelveTimesMajorIndexVarianceOfStandardTableauxSt001178Twelve times the variance of the major index over the standard tableaux: the sum of the first n squares, less the sum of the squared hook lengths.
• TwiceMeanMajorIndexOfStandardTableauxSt001177Twice the mean major index over the standard tableaux: n choose 2, less the sum of the row lengths choose 2, plus the sum of the column lengths choose 2.
• UpperCoverCountInDominanceOrderSt000481The partitions of the same size that cover this one in dominance order.
• WeightedSizeSt000185The sum of the parts weighted by their row, counting rows from 0.
• YoungLatticeCoveringRelationCountSt001360The covering relations of Young's lattice among the partitions contained in this one: the sum of their corners.

Maps

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

From IntegerPartition

• BinaryWordIntegerPartition → BinaryWordInjectionMp00095The shape's boundary read from the first row down: 1 for a step down, 0 for a step left.
• BulgarianSolitaireIntegerPartition → IntegerPartitionGraded mapMp00308A move of Bulgarian solitaire: the first column of the Ferrers diagram becomes a new row.
• GlaisherFranklinIntegerPartition → IntegerPartitionbijectioninverseBijectionGraded mapMp00312The Glaisher-Franklin bijection: even part sizes halved become repeated parts, and repeated odd parts merge into their binary multiples.
• InitialTableauIntegerPartition → StandardTableauInjectionGraded mapMp00042The standard tableau of the shape filled row by row with 1, 2, ..., n.
• InverseGlaisherFranklinIntegerPartition → IntegerPartitionbijectioninverseBijectionGraded mapMp00313The inverse of GlaisherFranklin: repeated parts merge into doubled parts, and a leftover part splits into copies of its odd part.
• MinimalDyckPathIntegerPartition → DyckPathInjectionMp00043The shortest Dyck path tracing the shape of the Ferrers diagram.
• OddPartsWordIntegerPartition → BinaryWordSurjectionMp00317The binary word marking which parts are odd, the parts taken largest first.
• ParallelogramPolyominoDyckPathIntegerPartition → DyckPathInjectionMp00230The Dyck path of the partition read as a parallelogram polyomino, one column per part.
• ReadingTableauIntegerPartition → StandardTableauInjectionGraded mapMp00045The recording tableau of the row reading word of the shape filled row by row.
• RemoveFirstPartIntegerPartition → IntegerPartitionSurjectionMp00202The partition without its largest part: its first row removed.
• TransposePartitionIntegerPartition → IntegerPartitioninvolutionBijectionGraded mapInvolutionMp00044The conjugate partition: column i of the Ferrers diagram becomes row i.

To IntegerPartition

• BlockSizePartitionSetPartition → IntegerPartitionsurjectionSurjectionGraded mapMp00079The partition of n a set partition's block sizes form, largest first.
• ConjugateAfterCycleTypePermutation → IntegerPartitionThe conjugate partition of the cycle type.
• CutOutPartitionDyckPath → IntegerPartitionInjectionMp00027The partition cut out of the staircase by the path: part i is the number of downs before the (n + 1 - i)-th up step.
• CycleTypePermutation → IntegerPartitionsurjectionSurjectionGraded mapMp00108The multiset of cycle lengths, as a partition.
• NegativeCycleTypeSignedPermutation → IntegerPartitionSurjectionMp00169The lengths of the negative cycles, largest first: those of the underlying permutation with an odd number of negative entries.
• PositiveCycleTypeSignedPermutation → IntegerPartitionSurjectionMp00166The lengths of the positive cycles, largest first: those of the underlying permutation with an even number of negative entries.
• RskShapePermutation → IntegerPartitionsurjectionSurjectionGraded mapMp00060The common shape of the RSK tableaux: the row lengths, as a partition of n.
• SortedPartitionIntegerComposition → IntegerPartitionsurjectionSurjectionGraded mapMp00040The partition a composition's parts form, sorted largest first.
• TableauShapeStandardTableau → IntegerPartitionsurjectionSurjectionGraded mapMp00083The shape of a standard tableau: its row lengths.

21 more in FindStat, not implemented here

• Mp00021CorePartition → IntegerPartitionGraded mapBijectionto bounded partition
• Mp00022CorePartition → IntegerPartitionSurjectionto partition
• Mp00037LabeledGraph → IntegerPartitionSurjectionGraded mapto partition of connected components
• Mp00077SemistandardTableau → IntegerPartitionSurjectionGraded mapshape
• Mp00110Posets → IntegerPartitionSurjectionGraded mapGreene-Kleitman invariant
• Mp00179IntegerPartition → SkewPartitionInjectionGraded mapto skew partition
• Mp00182SkewPartition → IntegerPartitionSurjectionouter shape
• Mp00183SkewPartition → IntegerPartitionSurjectioninner shape
• Mp00186SkewPartition → IntegerPartitionSurjectionGraded mapdominating partition
• Mp00204Permutation → IntegerPartitionSurjectionGraded mapLLPS
• Mp00225SemistandardTableau → IntegerPartitionSurjectionweight
• Mp00251LabeledGraph → IntegerPartitionclique sizes
• Mp00275LabeledGraph → IntegerPartitionSurjectionto edge-partition of connected components
• Mp00276LabeledGraph → IntegerPartitionto edge-partition of biconnected components
• Mp00306Posets → IntegerPartitionrowmotion cycle type
• Mp00307Posets → IntegerPartitionpromotion cycle type
• Mp00311PlanePartition → IntegerPartitionGraded mapto partition
• Mp00321IntegerPartition → IntegerPartitionBijectionGraded mapInvolution2-conjugate
• Mp00322IntegerPartition → IntegerPartitionBijectionGraded mapLoehr-Warrington
• Mp00323IntegerPartition → IntegerPartitionBijectionGraded mapLoehr-Warrington inverse
• Mp00332Posets → IntegerPartitionSurjectionGraded mapJordan block partition

Examples

Basic #

$\binom{5}{2} = 10$

live ↗

In$\mathrm{Count}(\mathrm{PartitionsInBox}(2, 3))$Out$10$

At most 2 parts, each at most 2

live ↗

In$\mathrm{Take}(\mathrm{PartitionsInBox}(2, 2), 6)$Out$\bigl\lbrack{\operatorname{IntegerPartition}}([2, 2]), {\operatorname{IntegerPartition}}([2, 1]), {\operatorname{IntegerPartition}}([1, 1]), {\operatorname{IntegerPartition}}([2]), {\operatorname{IntegerPartition}}([1]), {\operatorname{IntegerPartition}}([])\bigr\rbrack$

About

Examples	2
Crosswalk	OEIS

See also: IntegerPartitions, PartitionsMaxPart, PartitionsIntoKParts