Skip to content

LabeledTrees ​

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.

✓ checked against that system · ! checked, with disagreements (hover a chip)OEISA000272✓
LabeledTrees(...)Catalogued in the enumeratio database, with crosswalk rows in oeis; not yet written up here.
Typed signatures
TypePackageApplies
(integer<0..>) -> indexed_collection<labeled_tree>combinatoricsalways

Domain: Combinatorics

Definition

Epsil, as the implementation runs it.

count(_n)

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

unrank(_n, _r)

Apply((sq: list<integer>) => Apply(
                                    (peeled: list<integer>) => Map(
                                                                    Function([Fold(
                                                                                    Function(z_v if z_f == 0 &&
                                                                                                    peeled[z_v] == 1 else z_f, z_f, z_v),
                                                                                    0,
                                                                                    Range(1, _n, 1),
                                                                                  ), _n] if uj ==
                                                                                           _n - 1 else Apply(
                                                                                                        (el: integer) => Apply((ex: integer) => [Min(el, ex), Max(el, ex)], sq[uj]),
                                                                                                        peeled[_n + uj],
                                                                                                      ), uj),
                                                                    Range(
                                                                           1,
                                                                           _n -
                                                                           1,
                                                                           1,
                                                                         ),
                                                                  ),
                                    Apply(
                                           (us_init: list<integer>) => Fold(
                                                                             (us: list<integer>, ui) => Apply(
                                                                                                               (us_next: list<integer>) => us_next,
                                                                                                               Apply(
                                                                                                                      (ul: integer) => Apply((ux: integer) => ReplaceAt(ReplaceAt(ReplaceAt(us, ul, 0), ux, us[ux] - 1), _n + ui, ul), sq[ui]),
                                                                                                                      Fold(
                                                                                                                            Function(u_v if u_f == 0 &&
                                                                                                                                            us[u_v] == 1 else u_f, u_f, u_v),
                                                                                                                            0,
                                                                                                                            Range(1, _n, 1),
                                                                                                                          ),
                                                                                                                    ),
                                                                                                             ),
                                                                             us_init,
                                                                             Range(
                                                                                    1,
                                                                                    _n - 2,
                                                                                    1,
                                                                                  ),
                                                                           ),
                                           Join(
                                                 Map(
                                                      Function(
                                                                1 +
                                                                Count(Filter(
                                                                              sq,
                                                                              Function(py == pv, py),
                                                                            )),
                                                                pv,
                                                              ),
                                                      Range(1, _n, 1),
                                                    ),
                                                 Map(
                                                      Function(0, pz),
                                                      Range(1, _n - 2, 1),
                                                    ),
                                               ),
                                         ),
                                  ), Map(Function((_r - _r % _n ^ (_n - 2 - pj)) /
                                                 _n ^ (_n - 2 - pj) % _n + 1, pj), Range(
                                                                        1,
                                                                        _n - 2,
                                                                        1,
                                                                      )))

rank(_n, _x)

Apply((rs_init: list<integer>) => Fold(
                                        (rs: list<integer>, ri) => Apply(
                                                                          (rs_next: list<integer>) => rs_next,
                                                                          Apply(
                                                                                 (rl: integer) => Apply(
                                                                                                         (rn: integer) => ReplaceAt(
                                                                                                                                     ReplaceAt(ReplaceAt(rs, rl, 0), rn, rs[rn] - 1),
                                                                                                                                     _n + 1,
                                                                                                                                     rs[_n + 1] *
                                                                                                                                     _n +
                                                                                                                                     (rn - 1),
                                                                                                                                   ),
                                                                                                         Fold(Function(ne[2] if ne[1] == rl &&
                                                                                                                                0 < rs[ne[2]] else ne[1] if ne[2] == rl &&
                                                                                                                                               0 < rs[ne[1]] else nf, nf, ne), 0, _x),
                                                                                                       ),
                                                                                 Fold(
                                                                                       Function(r_v if r_f == 0 &&
                                                                                                       rs[r_v] == 1 else r_f, r_f, r_v),
                                                                                       0,
                                                                                       Range(1, _n, 1),
                                                                                     ),
                                                                               ),
                                                                        ),
                                        rs_init,
                                        Range(1, _n - 2, 1),
                                      ), Join(Map(Function(
                                                           Fold(Function(dg +
                                                                         (1 if de[1] ==
                                                                               dv ||
                                                                               de[2] ==
                                                                               dv else 0), dg, de), 0, _x),
                                                           dv,
                                                         ), Range(1, _n, 1)), [0]))[_n + 1]

valid(_n, _x)

(Apply((vs_init: list<integer>) => Fold(
                                         (vs: list<integer>, vi) => Apply(
                                                                           (vs_next: list<integer>) => vs_next,
                                                                           Apply(
                                                                                  (vl: integer) => ReplaceAt(vs, _n + 1, 0) if vl == 0 else Apply(
                                                                                                                                                   (vn: integer) => ReplaceAt(ReplaceAt(vs, vl, 0), vn, vs[vn] - 1),
                                                                                                                                                   Fold(Function(ne[2] if ne[1] == vl &&
                                                                                                                                                                          0 < vs[ne[2]] else ne[1] if ne[2] == vl &&
                                                                                                                                                                                         0 < vs[ne[1]] else nf, nf, ne), 0, _x),
                                                                                                                                                 ),
                                                                                  Fold(
                                                                                        Function(v_v if v_f == 0 &&
                                                                                                        vs[v_v] == 1 else v_f, v_f, v_v),
                                                                                        0,
                                                                                        Range(1, _n, 1),
                                                                                      ),
                                                                                ),
                                                                         ),
                                         vs_init,
                                         Range(1, _n - 1, 1),
                                       ), Join(Map(
                                                   Function(Fold(
                                                                  Function(dg +
                                                                           (1 if de[1] == dv ||
                                                                                 de[2] == dv else 0), dg, de),
                                                                  0,
                                                                  _x,
                                                                ), dv),
                                                   Range(1, _n, 1),
                                                 ), [1]))[_n + 1] == 1 if Fold(Function(ok &&
                                                                                       (1 <= ve[1] &&
                                                                                        ve[1] <= _n &&
                                                                                        1 <= ve[2] &&
                                                                                        ve[2] <= _n &&
                                                                                        ve[1] != ve[2] if Length(ve) == 2 else False), ok, ve), True, _x) else False) if Length(_x) ==
                                                                                                                           _n - 1 else False

Enumeration

About
CrosswalkOEIS