DistinctPartitions

A name from the enumeratio catalogue with no kernel of its own yet; this page carries its crosswalk only.

Catalogued in the enumeratio database, with crosswalk rows in mathlib4, oeis, sage, wolfram; not yet written up here.

✓ checked against that system · ! checked, with disagreements (hover a chip)OEISA000009✓↗A034320✓↗A280664✓↗A092833✓↗A347587✓↗A117409✓↗Wolfram LanguagePartitionsQ↗SageMathPartitions(n, max_slope=-1)↗mathlib4Nat.Partition.distincts↗

DistinctPartitions(...)Catalogued in the enumeratio database, with crosswalk rows in mathlib4, oeis, sage, wolfram; not yet written up here.

Typed signatures

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

Domain: Combinatorics

Definition

Epsil, as the implementation runs it.

count(_n)

_tables[_n * (_n + 1) + _n + 1]

unrank(_n, _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_chosen[2] - 1, 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) *
                                                                                                                                                                                             (_n + 1) +
                                                                                                                                                                                             (pw_p - 1) +
                                                                                                                                                                                             1],
                                                                                                                                                                                   ) if True else pw_pick, pw_pick, pw_p),
                                                                                                                                     [pw_r, 0],
                                                                                                                                     Range(Min(pw_m, pw_c), 1, -1),
                                                                                                                                   ),
                                                                                                                             ), pw_u[3]), pw_u[2]), pw_u[1]),
                      pw_u,
                      pw_i,
                    ),
            [_n, _n, _r],
            Range(1, _n, 1),
          ),
      3,
    )

rank(_n, _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) *
                                                                                                                   (_n + 1) +
                                                                                                                   (pw_q - 1) +
                                                                                                                   1] if True else 0), pw_s, pw_q),
                                                                                                 0,
                                                                                                 Range(
                                                                                                        pw_x + 1,
                                                                                                        Min(pw_m, pw_c),
                                                                                                        1,
                                                                                                      ),
                                                                                               ), pw_m - pw_x, pw_x - 1], pw_a[3]),
                                              pw_a[2],
                                            ), pw_a[1]), pw_a, pw_x), [0, _n, _n], _x)[1]

valid(_n, _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_y - 1] if pw_f == 1 &&
                                                                                                                                pw_y >= 1 &&
                                                                                                                                pw_y <=
                                                                                                                                Min(pw_m, pw_c) &&
                                                                                                                                True else [0, 0, 0],
                                                                               pw_v[3],
                                                                             ), pw_v[2]), pw_v[1]),
                      pw_v,
                      pw_y,
                    ), [1, _n, _n], _x),
     )

tables(_n)

Fold(
      Function(Join(
                     pw_t,
                     Fold(
                           Function(
                                     ReplaceAt(
                                                pw_row,
                                                pw_c + 1,
                                                Fold(
                                                      Function(pw_a +
                                                               (pw_t[(pw_s -
                                                                      pw_p) * (_n +
                                                                           1) +
                                                                     (pw_p - 1) +
                                                                     1] if True else 0), pw_a, pw_p),
                                                      0,
                                                      Range(
                                                             1,
                                                             Min(pw_s, pw_c),
                                                             1,
                                                           ),
                                                    ),
                                              ),
                                     pw_row,
                                     pw_c,
                                   ),
                           Map(Function(0, pw_z), Range(0, _n + 1 - 1, 1)),
                           Range(0, _n + 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, _n + 1 - 1, 1)),
            Range(0, _n + 1 - 1, 1),
          ),
      Range(1, _n + 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

Enumeration

Examples

Basic #

6 = 6 = 5+1 = 4+2 = 3+2+1: four partitions into distinct parts

live ↗

In$\mathrm{Count}(\mathrm{DistinctPartitions}(6))$Out$4$

The first three, in enumeration order

live ↗

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

Properties #

Ten partitions of 10 into distinct parts (A000009)

live ↗

In$\mathrm{Count}(\mathrm{DistinctPartitions}(10))$Out$10$

About

Examples	3
Checked against	mathlib4 3 agree
Crosswalk	OEIS ×6Wolfram LanguageSageMathmathlib4

Implementation

mappedmathlib4packages/oracle/src/mappings.ts

Nat.Partition.distincts, enumerated and ordered as IntegerPartitions