Skip to content

NonDecreasingParkingFunctions ​

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 oeis; not yet written up here.

NonDecreasingParkingFunctions(...)Catalogued in the enumeratio database, with crosswalk rows in oeis; not yet written up here.
Typed signatures
TypePackageApplies
(integer<0..>) -> indexed_collection<parking_function>combinatoricsalways

Domain: Combinatorics

Definition

Epsil, as the implementation runs it.

count(_n)

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

unrank(_n, _r)

Drop(Fold(Function(Apply(
                          (up: list<integer>) => Join(
                                                       [up[1], up[2]],
                                                       Drop(us, 2),
                                                       [up[2]],
                                                     ),
                          Fold(Function(
                                         ([uq[1], ua] if uq[1] < _tables[(_n -
                                                                          ui) * (_n +
                                                                               2) +
                                                                         ua + 1] else [uq[1] -
                                                                                 _tables[(_n - ui) *
                                                                                         (_n + 2) + ua + 1], 0]) if uq[2] == 0 else uq,
                                         uq,
                                         ua,
                                       ), [us[1], 0], Range(us[2], ui, 1)),
                        ), us, ui), [_r, 1], Range(1, _n, 1)), 2)

rank(_n, _x)

Fold(Function([rs[1] + Fold(
                             Function(rt +
                                      _tables[(_n - ri) * (_n + 2) + ra + 1], rt, ra),
                             0,
                             Range(rs[2], _x[ri] - 1, 1),
                           ), _x[ri]], rs, ri), [0, 1], Range(1, _n, 1))[1]

valid(_n, _x)

Length(_x) == _n && Fold(
                          Function(ok_i && 1 <= _x[i] && _x[i] <= i &&
                                           (True if i == 1 else _x[i - 1] <=
                                                                _x[i]), ok_i, i),
                          True,
                          Range(1, Length(_x), 1),
                        )

tables(_n)

Fold(
      Function(Join(
                     pf_t,
                     Fold(
                           Function(
                                     ReplaceAt(
                                                pf_row,
                                                pf_c + 1,
                                                Fold(
                                                      Function(
                                                                pt + pf_t[(pf_s -
                                                                           1) *
                                                                          (_n +
                                                                           2) +
                                                                          pa + 1],
                                                                pt,
                                                                pa,
                                                              ),
                                                      0,
                                                      Range(
                                                             pf_c,
                                                             _n + 1 - pf_s,
                                                             1,
                                                           ),
                                                    ),
                                              ),
                                     pf_row,
                                     pf_c,
                                   ),
                           Map(Function(0, pf_z), Range(0, _n + 2 - 1, 1)),
                           Range(0, _n + 2 - 1, 1),
                         ),
                   ), pf_t, pf_s),
      Fold(
            Function(ReplaceAt(pf_row, pf_c + 1, 1), pf_row, pf_c),
            Map(Function(0, pf_z), Range(0, _n + 2 - 1, 1)),
            Range(0, _n + 2 - 1, 1),
          ),
      Range(1, _n + 1 - 1, 1),
    )

Statistics

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

Maps

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

From ParkingFunction

  • CarPermutationParkingFunction → PermutationSurjectionGraded mapMp00053Spot j holds the car that parks there, each car taking the first free spot at or after its preference.
  • CyclicShiftParkingFunction → ParkingFunctioninverseBijectionGraded mapMp00293Rotate the word one place to the left: the first entry moves to the end.
  • InverseCyclicShiftParkingFunction → ParkingFunctioninverseBijectionGraded mapMp00304Rotate the word one place to the right: the last entry moves to the front.
  • LabelingPermutationParkingFunction → PermutationSurjectionGraded mapMp00055The labeling of the parking function's support Dyck path: the positions of the entries, smallest entry first and equal entries left to right.
  • ReverseParkingFunction → ParkingFunctioninvolutionBijectionGraded mapInvolutionMp00320The word read backwards.
  • SupportDyckPathParkingFunction → DyckPathSurjectionGraded mapMp00056The Dyck path whose area sequence is j minus the j-th smallest entry: the parking function's support.
13 more in FindStat, not implemented here
  • Mp00052ParkingFunction → ParkingFunctionIdempotentGraded mapto non-decreasing parking function
  • Mp00054ParkingFunction → IntegerCompositionSurjectionGraded mapto inverse des composition
  • Mp00057ParkingFunction → IntegerCompositionSurjectionGraded mapto touch composition
  • Mp00290ParkingFunction → SetCompositionSurjectionGraded mapto ordered set partition
  • Mp00297ParkingFunction → OrderedTreeSurjectionGraded mapordered tree
  • Mp00298ParkingFunction → ParkingFunctionBijectionGraded maprepeats to leading
  • Mp00299ParkingFunction → ParkingFunctionBijectionGraded mapones to leading
  • Mp00300ParkingFunction → ParkingFunctionBijectionGraded mapleading to ones
  • Mp00301ParkingFunction → ParkingFunctionBijectionGraded mapleading to repeats
  • Mp00302ParkingFunction → SemistandardTableauGraded mapinsertion tableau
  • Mp00303ParkingFunction → ParkingFunctionBijectionGraded mapInvolutioncomplement
  • Mp00305Permutation → ParkingFunctionInjectionGraded mapparking function
  • Mp00319ParkingFunction → IntegerCompositionInjectionto composition

Enumeration

About
CrosswalkOEIS