SemistandardTableaux
Semistandard Young tableaux of cells with entries in , summed over every shape , as a lazy indexed family.
Wikipedia
Young tableauMathWorldYoungTableauWikidataQ2166280nLabYoung diagramSageMathSemistandardTableaux(n)mathlib4SemistandardYoungTableauSemistandardTableaux(size, max_entry)the SSYT of size cells over every partition shape, entries from 1 to max_entry.Typed signatures
| Type | Package | Applies |
|---|---|---|
(integer<0..>, integer<0..>) -> indexed_collection<list<list<integer>>> | combinatorics | always |
Details
- A lazy indexed collection; the count is the hook-content formula , summed over every shape — exact and closed-form.
- Each element is the filling's rows: weakly increasing left to right, strictly increasing top to bottom — semistandard, not standard, so entries may repeat within a row (unlike a standard Young tableau).
- Unranked in shape-then-entries order: by row-length shape first, then the flattened filling.
Definition
Epsil, as the implementation runs it.
count(_n, _k)
Fold(
Function(ss_b + _tables[(_n + 1) * (_n + 1) + ss_i + 1], ss_b, ss_i),
0,
Range(0, _tables[_n * (_n + 1) + _n + 1] - 1, 1),
)unrank(_n, _k, _r)
Apply(
(ss_found: list<integer>) => Apply(
(ss_S: list<integer>) => Apply(
(ss_W: list<integer>) => Apply(
(ss_end: list<integer>) => Map(
Function(Take(Drop(
Drop(ss_end, 1),
Fold(
Function(ss_q + ss_S[ss_u], ss_q, ss_u),
0,
Range(1, ss_j - 1, 1),
),
), ss_S[ss_j]), ss_j),
Range(1, Fold(Function(fh_a +
(1 if ss_S[fh_r] > 0 else 0), fh_a, fh_r), 0, Range(1, _n, 1)), 1),
),
Apply((ss_u_init: list<integer>) => Fold(
(ss_u: list<integer>, ss_j) => Apply(
(ss_u_next: list<integer>) => ss_u_next,
Apply((ss_m: integer) => Apply(
(ss_o: integer) => Apply((ss_at: integer) => Apply(
(ss_up: list<integer>) => Apply(
(ss_found2: list<integer>) => Join([ss_found2[1]], Take(Drop(ss_u, 1), ss_at), Drop(ss_found2, 2)),
Apply((ss_c_init: list<integer>) => Fold(
(ss_c: list<integer>, ss_i) => Apply(
(ss_c_next: list<integer>) => ss_c_next,
ss_c if ss_c[2] == 1 else Apply((ss_row: list<integer>) => Apply((ss_v: integer) => Join([ss_c[1], 1], ss_row) if ss_c[1] < ss_v else Join([ss_c[1] - ss_v, 0], Apply(
(ss_at: integer) => ss_row if ss_at == 0 else Map(Function(ss_row[ss_j] if ss_j < ss_at else ss_row[ss_at] + 1, ss_j), Range(1, ss_m, 1)),
Fold(Function(ss_i if ss_row[ss_i] < _k else ss_r, ss_r, ss_i), 0, Range(1, ss_m, 1)),
)), ss_W[ss_o + ss_i]) if Fold(Function(ok_ss_fc &&
ss_row[ss_fc] > ss_up[ss_fc], ok_ss_fc, ss_fc), True, Range(1, ss_m, 1)) else Join([ss_c[1], 0], Apply(
(ss_at: integer) => ss_row if ss_at == 0 else Map(Function(ss_row[ss_j] if ss_j < ss_at else ss_row[ss_at] + 1, ss_j), Range(1, ss_m, 1)),
Fold(Function(ss_i if ss_row[ss_i] < _k else ss_r, ss_r, ss_i), 0, Range(1, ss_m, 1)),
)), Drop(ss_c, 2)),
),
ss_c_init,
Range(1, Binomial(ss_m +
(_k - 1), ss_m) if 0 <= ss_m &&
ss_m <=
ss_m +
(_k - 1) else 0, 1),
), Join([ss_u[1], 0], Map(Function(1, ss_o), Range(1, ss_m, 1)))),
),
Map(Function(0, sy_z), Range(1, ss_m, 1)) if ss_j == 1 else Take(Drop(Drop(ss_u, 1), Fold(Function(ss_q + ss_S[ss_u], ss_q, ss_u), 0, Range(1, ss_j - 1 -
1, 1))), ss_m),
), Fold(Function(ss_q + ss_S[ss_u], ss_q, ss_u), 0, Range(1, ss_j - 1, 1))),
Fold(Function(ss_q +
(Binomial(ss_S[ss_u] +
(_k - 1), ss_S[ss_u]) if 0 <= ss_S[ss_u] &&
ss_S[ss_u] <=
ss_S[ss_u] +
(_k - 1) else 0), ss_q, ss_u), 0, Range(1, ss_j - 1, 1)),
), ss_S[ss_j]),
),
ss_u_init,
Range(1, Fold(Function(fh_a +
(1 if ss_S[fh_r] > 0 else 0), fh_a, fh_r), 0, Range(1, _n, 1)), 1),
), [ss_found[1]]),
),
Apply(
(ss_L: integer) => Apply(
(ss_state_init: list<integer>) => Fold((ss_state: list<integer>, ss_t) => Apply(
(ss_state_next: list<integer>) => ss_state_next,
Apply((ss_j: integer) => Apply((ss_m: integer) => Apply((ss_m2: integer) => Apply(
(ss_here: integer) => Apply(
(ss_next: integer) => Drop(Apply((ss_s_init: list<integer>) => Fold(
(ss_s: list<integer>, ss_g) => Apply(
(ss_s_next: list<integer>) => ss_s_next,
Apply((ss_cur: list<integer>) => Apply((ss_w: list<integer>) => Apply(
(ss_sum: integer) => Join(Apply(
(ss_at: integer) => ss_cur if ss_at == 0 else Map(Function(ss_cur[ss_j] if ss_j < ss_at else ss_cur[ss_at] + 1, ss_j), Range(1, ss_m, 1)),
Fold(Function(ss_i if ss_cur[ss_i] < _k else ss_r, ss_r, ss_i), 0, Range(1, ss_m, 1)),
), ReplaceAt(ss_w, ss_here + ss_g, ss_sum)),
Apply((ss_y_init: list<integer>) => Fold(
(ss_y: list<integer>, ss_h) => Apply(
(ss_y_next: list<integer>) => ss_y_next,
Apply((ss_acc: integer) => Apply((ss_row: list<integer>) => Join(
[ss_acc +
ss_w[ss_next + ss_h] if Fold(Function(ok_ss_fc &&
ss_row[ss_fc] > ss_cur[ss_fc], ok_ss_fc, ss_fc), True, Range(1, ss_m2, 1)) else ss_acc],
Apply(
(ss_at: integer) => ss_row if ss_at == 0 else Map(Function(ss_row[ss_j] if ss_j < ss_at else ss_row[ss_at] + 1, ss_j), Range(1, ss_m2, 1)),
Fold(Function(ss_i if ss_row[ss_i] < _k else ss_r, ss_r, ss_i), 0, Range(1, ss_m2, 1)),
),
), Drop(ss_y, 1)), ss_y[1]),
),
ss_y_init,
Range(1, Binomial(ss_m2 +
(_k - 1), ss_m2) if 0 <= ss_m2 &&
ss_m2 <=
ss_m2 +
(_k - 1) else 0, 1),
), Join([0], Map(Function(1, ss_o), Range(1, ss_m2, 1))))[1],
), Drop(ss_s, ss_m)), Take(ss_s, ss_m)),
),
ss_s_init,
Range(1, Binomial(ss_m +
(_k - 1), ss_m) if 0 <= ss_m &&
ss_m <=
ss_m +
(_k - 1) else 0, 1),
), Join(Map(Function(1, ss_o), Range(1, ss_m, 1)), ss_state)), ss_m),
Fold(Function(ss_q +
(Binomial(ss_S[ss_u] +
(_k - 1), ss_S[ss_u]) if 0 <= ss_S[ss_u] &&
ss_S[ss_u] <=
ss_S[ss_u] +
(_k - 1) else 0), ss_q, ss_u), 0, Range(1, ss_j + 1 -
1, 1)),
),
Fold(Function(ss_q +
(Binomial(ss_S[ss_u] +
(_k - 1), ss_S[ss_u]) if 0 <= ss_S[ss_u] &&
ss_S[ss_u] <=
ss_S[ss_u] +
(_k - 1) else 0), ss_q, ss_u), 0, Range(1, ss_j - 1, 1)),
), ss_S[ss_j + 1]), ss_S[ss_j]), ss_L - ss_t),
), ss_state_init, Range(1, ss_L - 1, 1)),
Map(
Function(1, ss_o),
Range(1, Fold(
Function(ss_q +
(Binomial(ss_S[ss_u] +
(_k - 1), ss_S[ss_u]) if 0 <= ss_S[ss_u] &&
ss_S[ss_u] <=
ss_S[ss_u] +
(_k - 1) else 0), ss_q, ss_u),
0,
Range(1, ss_L + 1 -
1, 1),
), 1),
),
),
Fold(
Function(fh_a +
(1 if ss_S[fh_r] > 0 else 0), fh_a, fh_r),
0,
Range(1, _n, 1),
),
),
),
Apply(
(sy_parts: list<integer>) => Join(
sy_parts,
Map(
Function(0, sy_z),
Range(1, _n - Length(sy_parts), 1),
),
),
Apply(
(ss_pr: integer) => 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], 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],
) 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, ss_pr],
Range(1, _n, 1),
), 3),
_tables[_n * (_n + 1) +
_n + 1] - 1 -
ss_found[2],
),
),
),
Apply((ss_f_init: list<integer>) => Fold(
(ss_f: list<integer>, ss_i) => Apply(
(ss_f_next: list<integer>) => ss_f_next,
ss_f if ss_f[2] >= 0 else Apply(
(ss_w: integer) => [ss_f[1], ss_i] if ss_f[1] < ss_w else [ss_f[1] - ss_w, -1],
_tables[(_n + 1) *
(_n + 1) + ss_i + 1],
),
),
ss_f_init,
Range(
0,
_tables[_n * (_n + 1) +
_n + 1] - 1,
1,
),
), [_r, -1]),
)rank(_n, _k, _x)
Apply((ss_h: list<integer>) => Apply(
(ss_place: integer) => Apply(
(ss_S: list<integer>) => Apply(
(ss_W: list<integer>) => Fold(
Function(ss_b +
_tables[(_n + 1) *
(_n + 1) + ss_i + 1], ss_b, ss_i),
0,
Range(0, ss_place - 1, 1),
) +
Fold(
Function(Apply((ss_m: integer) => Apply(
(ss_o: integer) => Apply((ss_target: list<integer>) => Apply(
(ss_up: list<integer>) => ss_acc +
Apply((ss_c_init: list<integer>) => Fold(
(ss_c: list<integer>, ss_i) => Apply(
(ss_c_next: list<integer>) => ss_c_next,
ss_c if ss_c[2] == 1 else Apply((ss_row: list<integer>) => Join([ss_c[1], 1], ss_row) if 0 ==
Fold(Function(ss_d +
Abs(ss_row[ss_sc] - ss_target[ss_sc]), ss_d, ss_sc), 0, Range(1, ss_m, 1)) else Join(
[ss_c[1] +
ss_W[ss_o + ss_i] if Fold(Function(ok_ss_fc &&
ss_row[ss_fc] > ss_up[ss_fc], ok_ss_fc, ss_fc), True, Range(1, ss_m, 1)) else ss_c[1], 0],
Apply(
(ss_at: integer) => ss_row if ss_at == 0 else Map(Function(ss_row[ss_j] if ss_j < ss_at else ss_row[ss_at] + 1, ss_j), Range(1, ss_m, 1)),
Fold(Function(ss_i if ss_row[ss_i] < _k else ss_r, ss_r, ss_i), 0, Range(1, ss_m, 1)),
),
), Drop(ss_c, 2)),
),
ss_c_init,
Range(1, Binomial(ss_m +
(_k - 1), ss_m) if 0 <= ss_m &&
ss_m <=
ss_m +
(_k - 1) else 0, 1),
), Join([0, 0], Map(Function(1, ss_o), Range(1, ss_m, 1))))[1],
Map(Function(0, sy_z), Range(1, ss_m, 1)) if ss_j == 1 else Apply((ss_above: list<integer>) => Take(ss_above, ss_m), _x[ss_j - 1]),
), _x[ss_j]),
Fold(Function(ss_q +
(Binomial(ss_S[ss_u] +
(_k - 1), ss_S[ss_u]) if 0 <= ss_S[ss_u] &&
ss_S[ss_u] <=
ss_S[ss_u] +
(_k - 1) else 0), ss_q, ss_u), 0, Range(1, ss_j - 1, 1)),
), ss_S[ss_j]), ss_acc, ss_j),
0,
Range(1, Fold(Function(fh_a +
(1 if ss_S[fh_r] > 0 else 0), fh_a, fh_r), 0, Range(1, _n, 1)), 1),
),
Apply(
(ss_L: integer) => Apply(
(ss_state_init: list<integer>) => Fold((ss_state: list<integer>, ss_t) => Apply(
(ss_state_next: list<integer>) => ss_state_next,
Apply((ss_j: integer) => Apply((ss_m: integer) => Apply((ss_m2: integer) => Apply(
(ss_here: integer) => Apply(
(ss_next: integer) => Drop(Apply((ss_s_init: list<integer>) => Fold(
(ss_s: list<integer>, ss_g) => Apply(
(ss_s_next: list<integer>) => ss_s_next,
Apply((ss_cur: list<integer>) => Apply((ss_w: list<integer>) => Apply(
(ss_sum: integer) => Join(Apply(
(ss_at: integer) => ss_cur if ss_at == 0 else Map(Function(ss_cur[ss_j] if ss_j < ss_at else ss_cur[ss_at] + 1, ss_j), Range(1, ss_m, 1)),
Fold(Function(ss_i if ss_cur[ss_i] < _k else ss_r, ss_r, ss_i), 0, Range(1, ss_m, 1)),
), ReplaceAt(ss_w, ss_here + ss_g, ss_sum)),
Apply((ss_y_init: list<integer>) => Fold(
(ss_y: list<integer>, ss_h) => Apply(
(ss_y_next: list<integer>) => ss_y_next,
Apply((ss_acc: integer) => Apply((ss_row: list<integer>) => Join(
[ss_acc +
ss_w[ss_next + ss_h] if Fold(Function(ok_ss_fc &&
ss_row[ss_fc] > ss_cur[ss_fc], ok_ss_fc, ss_fc), True, Range(1, ss_m2, 1)) else ss_acc],
Apply(
(ss_at: integer) => ss_row if ss_at == 0 else Map(Function(ss_row[ss_j] if ss_j < ss_at else ss_row[ss_at] + 1, ss_j), Range(1, ss_m2, 1)),
Fold(Function(ss_i if ss_row[ss_i] < _k else ss_r, ss_r, ss_i), 0, Range(1, ss_m2, 1)),
),
), Drop(ss_y, 1)), ss_y[1]),
),
ss_y_init,
Range(1, Binomial(ss_m2 +
(_k - 1), ss_m2) if 0 <= ss_m2 &&
ss_m2 <=
ss_m2 +
(_k - 1) else 0, 1),
), Join([0], Map(Function(1, ss_o), Range(1, ss_m2, 1))))[1],
), Drop(ss_s, ss_m)), Take(ss_s, ss_m)),
),
ss_s_init,
Range(1, Binomial(ss_m +
(_k - 1), ss_m) if 0 <= ss_m &&
ss_m <=
ss_m +
(_k - 1) else 0, 1),
), Join(Map(Function(1, ss_o), Range(1, ss_m, 1)), ss_state)), ss_m),
Fold(Function(ss_q +
(Binomial(ss_S[ss_u] +
(_k - 1), ss_S[ss_u]) if 0 <= ss_S[ss_u] &&
ss_S[ss_u] <=
ss_S[ss_u] +
(_k - 1) else 0), ss_q, ss_u), 0, Range(1, ss_j + 1 -
1, 1)),
),
Fold(Function(ss_q +
(Binomial(ss_S[ss_u] +
(_k - 1), ss_S[ss_u]) if 0 <= ss_S[ss_u] &&
ss_S[ss_u] <=
ss_S[ss_u] +
(_k - 1) else 0), ss_q, ss_u), 0, Range(1, ss_j - 1, 1)),
), ss_S[ss_j + 1]), ss_S[ss_j]), ss_L - ss_t),
), ss_state_init, Range(1, ss_L - 1, 1)),
Map(
Function(1, ss_o),
Range(1, Fold(
Function(ss_q +
(Binomial(ss_S[ss_u] +
(_k - 1), ss_S[ss_u]) if 0 <= ss_S[ss_u] &&
ss_S[ss_u] <=
ss_S[ss_u] +
(_k - 1) else 0), ss_q, ss_u),
0,
Range(1, ss_L + 1 -
1, 1),
), 1),
),
),
Fold(
Function(fh_a +
(1 if ss_S[fh_r] > 0 else 0), fh_a, fh_r),
0,
Range(1, _n, 1),
),
),
),
Apply(
(sy_parts: list<integer>) => Join(
sy_parts,
Map(
Function(0, sy_z),
Range(1, _n - Length(sy_parts), 1),
),
),
ss_h,
),
),
_tables[_n * (_n + 1) + _n + 1] - 1 -
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] 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], pw_a[3]),
pw_a[2],
), pw_a[1]), pw_a, pw_x),
[0, _n, _n],
ss_h,
)[1],
), Map(
Function(Apply(
(ss_r: list<integer>) => Length(ss_r),
_x[ss_i],
), ss_i),
Range(1, Length(_x), 1),
))valid(_n, _k, _x)
Fold(Function(ok_sv_i && Apply(
(sv_r: list<integer>) => Length(sv_r) >= 1,
_x[sv_i],
), ok_sv_i, sv_i), True, Range(1, Length(_x), 1)) &&
Fold(
Function(ok_sv_h && Apply((sv_r: list<integer>) => Apply(
(sv_q: list<integer>) => Length(sv_r) <= Length(sv_q) &&
Fold(
Function(ok_sv_c &&
sv_q[sv_c] < sv_r[sv_c], ok_sv_c, sv_c),
True,
Range(1, Length(sv_r), 1),
),
_x[sv_h - 1],
), _x[sv_h]), ok_sv_h, sv_h),
True,
Range(2, Length(_x), 1),
) && Fold(Function(ok_sv_j &&
Apply(
(sv_r: list<integer>) => Fold(
Function(
ok_sv_d &&
sv_r[sv_d] >=
1 && sv_r[sv_d] <=
_k,
ok_sv_d,
sv_d,
),
True,
Range(
1,
Length(sv_r),
1,
),
) && Fold(
Function(ok_sv_e &&
sv_r[sv_e - 1] <=
sv_r[sv_e], ok_sv_e, sv_e),
True,
Range(
2,
Length(sv_r),
1,
),
),
_x[sv_j],
), ok_sv_j, sv_j), True, Range(1, Length(_x), 1)) && Fold(
Function(sv_t +
Apply((sv_r: list<integer>) => Length(sv_r), _x[sv_i]), sv_t, sv_i),
0,
Range(1, Length(_x), 1),
) ==
_ntables(_n, _k)
Apply(
(_tables: list<integer>) => Join(
_tables,
Map(Function(Apply(
(ss_shape: list<integer>) => Apply(
(fh_L: integer) => Apply(
(fh_M: integer) => Apply(
(fh_C: list<integer>) => 0 if fh_L > _k else Fold(
Function(Apply(
(fh_e: integer) => Fold(Function(fh_w * fh_p, fh_w, fh_k), fh_acc, Range(1, fh_e, 1)),
Apply((fh_st_init: list<integer>) => Fold((fh_st: list<integer>, fh_j) => Apply(
(fh_st_next: list<integer>) => fh_st_next,
fh_st if fh_st[2] >
_k + _n else Apply((fh_q: integer) => [fh_st[1] +
(Fold(Function(fh_a +
Fold(Function(fh_b +
(1 if (_k + fh_c -
fh_r) %
fh_q ==
0 else 0), fh_b, fh_c), 0, Range(1, ss_shape[fh_r], 1)), fh_a, fh_r), 0, Range(1, fh_L, 1)) -
Fold(Function(fh_a +
Fold(Function(fh_b +
(1 if (ss_shape[fh_r] - fh_c +
(fh_C[fh_c] - fh_r) +
1) %
fh_q ==
0 else 0), fh_b, fh_c), 0, Range(1, ss_shape[fh_r], 1)), fh_a, fh_r), 0, Range(1, fh_L, 1))), fh_q * fh_p], fh_st[2]),
), fh_st_init, Range(1, _k + _n, 1)), [0, fh_p])[1],
) if Fold(Function(ok_fh_d &&
fh_p % fh_d !=
0, ok_fh_d, fh_d), True, Range(2, fh_p - 1, 1)) else fh_acc, fh_acc, fh_p),
1,
Range(2, _k + _n, 1),
),
Map(
Function(Fold(Function(fh_a +
(1 if ss_shape[fh_r] >= fh_c else 0), fh_a, fh_r), 0, Range(1, fh_L, 1)), fh_c),
Range(1, _n, 1),
),
),
Fold(
Function(fh_a + ss_shape[fh_r], fh_a, fh_r),
0,
Range(1, _n, 1),
),
),
Fold(
Function(fh_a +
(1 if ss_shape[fh_r] > 0 else 0), fh_a, fh_r),
0,
Range(1, _n, 1),
),
),
Apply(
(sy_parts: list<integer>) => Join(
sy_parts,
Map(
Function(0, sy_z),
Range(1, _n - Length(sy_parts), 1),
),
),
Apply(
(ss_pr: integer) => 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], 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],
) 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, ss_pr],
Range(1, _n, 1),
), 3),
_tables[_n *
(_n + 1) + _n + 1] -
1 -
ss_i,
),
),
), ss_i), Range(
0,
_tables[_n *
(_n + 1) + _n + 1] -
1,
1,
)),
),
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] 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)),
)Enumeration
Examples
1 more kept as data, checked against the oracles See also: IntegerPartitions, Count, At