SkewPartitions
Reduced skew shapes with cells — no empty row or column — as a lazy indexed family.
SageMath
SkewPartitions(n)SkewPartitions(size)the reduced skew shapes with size cells total ().Typed signatures
| Type | Package | Applies |
|---|---|---|
(integer<0..>) -> indexed_collection<list<list<integer>>> | combinatorics | always |
Details
- A lazy indexed collection with no closed form, following Sage's
SkewPartitions(n): the count is a table over the last row of a shape and the cells left (exact, until it passes at , where the count is unknown), and a place in the order is found by walking that table, soAtis quick at sizes whose whole list is far too long. - Each element packs both partitions as
[λ, μ]; "reduced" means every row of strictly exceeds the matching row of (no empty row) and every column is covered by some row's cells (no empty column). has no zero parts:[[2, 1], [1, 0]]is not an element,[[2, 1], [1]]is. - Unranked lexicographically, by first, then by .
Definition
Epsil, as the implementation runs it.
count(_n)
(1 if _n == 0 else 0) if _n < 1 else Fold(
Function(sc_a + Fold(
Function(sc_b +
_tables[(_n -
(sc_hi - sc_lo +
1)) *
_n *
_n +
(sc_lo - 1) *
_n +
sc_hi], sc_b, sc_lo),
0,
Range(
1,
sc_hi,
1,
),
), sc_a, sc_hi),
0,
Range(1, _n, 1),
)unrank(_n, _r)
[[], []] if _n < 1 else Apply(
(sp_p1: list<integer>) => Apply((sp_bs: list<integer>) => Apply(
(sp_rows: integer) => Apply(
(sp_h: list<integer>) => Apply(
(sp_p2: list<integer>) => Apply((sp_as: list<integer>) => [
Take(sp_bs, sp_rows),
Take(
Map(Function(sp_as[sp_i] - 1, sp_i), Range(1, sp_rows, 1)),
Fold(Function(sp_n +
(1 if sp_as[sp_i] > 1 else 0), sp_n, sp_i), 0, Range(1, sp_rows, 1)),
),
], Drop(sp_p2, 3)),
Fold(
Function(sp_q if sp_t > sp_rows else Apply((sp_b: integer) => Apply(
(sp_fd: list<integer>) => Join([sp_fd[1], sp_q[2] +
sp_b - sp_fd[2] +
1, sp_fd[2]], ReplaceAt(Drop(sp_q, 3), sp_t, sp_fd[2])),
Fold(
Function(sp_f if sp_f[2] > 0 else Apply(
(sp_size: integer) => [sp_f[1], sp_o] if sp_f[1] < sp_size else [sp_f[1] - sp_size, 0],
0 if _n - sp_q[2] -
(sp_b - sp_o +
1) <
0 else sp_h[(sp_rows - sp_t) *
(_n + 1) *
(_n + 1) +
sp_o *
(_n + 1) +
(_n - sp_q[2] -
(sp_b - sp_o +
1)) +
1],
), sp_f, sp_o),
[sp_q[1], 0],
Range(1, Min(sp_b, sp_q[3]), 1),
),
), sp_bs[sp_t]), sp_q, sp_t),
Join([sp_p1[1], 0, _n], Map(Function(0, sp_z), Range(1, _n, 1))),
Range(1, _n, 1),
),
),
Fold(Function(Join(
sp_h,
ReplaceAt(Map(
Function(0, sp_z),
Range(1, (_n + 1) *
(_n + 1), 1),
), _n + 1 +
1, 1) if sp_j == 0 else Apply((sp_below: integer) => Apply(
(sp_prev: list<integer>) => Map(
Function(Apply((sp_a: integer) => Apply(
(sp_c: integer) => Fold(Function(sp_s +
(sp_prev[sp_a2 *
(_n + 1) +
(sp_c -
(sp_below - sp_a2 +
1)) +
1] if sp_c >=
sp_below - sp_a2 +
1 else 0), sp_s, sp_a2), 0, Range(1, Min(sp_below, sp_a), 1)) if sp_a >= 1 &&
sp_a <=
sp_below + 1 else 0,
sp_i %
(_n + 1),
), (sp_i -
sp_i %
(_n + 1)) /
(_n + 1)), sp_i),
Range(0, (_n + 1) *
(_n + 1) -
1, 1),
),
Drop(sp_h, (sp_j - 1) *
(_n + 1) *
(_n + 1)),
), sp_bs[sp_rows - sp_j +
1]),
), sp_h, sp_j), [], Range(0, sp_rows - 1, 1)),
),
Fold(
Function(sr_a +
(1 if sp_bs[sr_i] > 0 else 0), sr_a, sr_i),
0,
Range(1, _n, 1),
),
), Drop(sp_p1, 2 +
(_n + 1) *
(_n + 1))),
Fold(
Function(sp_st if sp_st[2] == 0 else Apply(
(sp_g: list<integer>) => Apply(
(sp_bs: list<integer>) => Apply(
(sp_end: integer) => Join([sp_st[1], 0], sp_g, sp_bs) if sp_st[1] < sp_end else Apply(
(sp_fd: list<integer>) => Join(
[sp_fd[1], sp_fd[2]],
Map(Function(Apply(
(sp_a1: integer) => Apply((sp_c1: integer) => Apply(
(sp_k: integer) => Fold(Function(sp_s +
sp_g[sp_a *
(_n + 1) +
(sp_c1 - sp_k) +
1], sp_s, sp_a), 0, Range(0 if sp_t == 1 else sp_a1, 0 if sp_t == 1 else Min(sp_fd[2] + 1, _n), 1)) if sp_c1 >= sp_k else 0,
sp_fd[2] - sp_a1 +
1,
) if sp_a1 >= 1 &&
sp_a1 <= sp_fd[2] else 0, sp_i %
(_n + 1)),
(sp_i -
sp_i %
(_n + 1)) /
(_n + 1),
), sp_i), Range(0, (_n + 1) *
(_n + 1) -
1, 1)),
ReplaceAt(sp_bs, sp_t, sp_fd[2]),
),
Fold(
Function(sp_f if sp_f[2] > 0 else Apply(
(sp_size: integer) => [sp_f[1], sp_o] if sp_f[1] < sp_size else [sp_f[1] - sp_size, 0],
Fold(Function(sp_w +
Apply((sp_k: integer) => Fold(Function(sp_u +
Fold(Function(sp_v +
sp_g[sp_a *
(_n + 1) + sp_c + 1] *
_tables[(_n - sp_c -
sp_k) * _n * _n +
(sp_b - 1) *
_n +
sp_o], sp_v, sp_c), 0, Range(0, _n - sp_k, 1)), sp_u, sp_a), 0, Range(0 if sp_t == 1 else sp_b, 0 if sp_t == 1 else Min(sp_o + 1, _n), 1)), sp_o - sp_b +
1), sp_w, sp_b), 0, Range(1, sp_o, 1)),
), sp_f, sp_o),
[sp_st[1] - sp_end, 0],
Range(1, sp_st[2], 1),
),
),
sp_g[(0 if sp_t == 1 else 1) *
(_n + 1) + _n + 1],
),
Drop(sp_st, 2 +
(_n + 1) *
(_n + 1)),
),
Take(
Drop(sp_st, 2),
(_n + 1) *
(_n + 1),
),
), sp_st, sp_t),
Join(
[_r, _n],
ReplaceAt(
Map(
Function(0, sp_z),
Range(1, (_n + 1) *
(_n + 1), 1),
),
1,
1,
),
Map(
Function(0, sp_z),
Range(1, _n, 1),
),
),
Range(1, _n, 1),
),
)rank(_n, _x)
0 if _n < 1 else Apply((sp_lam: list<integer>) => Apply((sp_mu: list<integer>) => Apply((sp_rows: integer) => Apply(
(sp_p1: list<integer>) => Apply(
(sp_h: list<integer>) => Fold(
Function(Apply((sp_b: integer) => Apply((sp_a: integer) => [sp_q[1] +
Fold(Function(sp_x +
(0 if _n - sp_q[2] -
(sp_b - sp_o +
1) <
0 else sp_h[(sp_rows - sp_t) *
(_n + 1) *
(_n + 1) +
sp_o *
(_n + 1) +
(_n - sp_q[2] -
(sp_b - sp_o +
1)) +
1]), sp_x, sp_o), 0, Range(1, Min(sp_a - 1, sp_b, sp_q[3]), 1)), sp_q[2] +
sp_b - sp_a +
1, sp_a], (sp_mu[sp_t] if sp_t <= Length(sp_mu) else 0) +
1), sp_lam[sp_t]), sp_q, sp_t),
[sp_p1[1], 0, _n],
Range(1, sp_rows, 1),
)[1],
Fold(Function(Join(
sp_h,
ReplaceAt(Map(
Function(0, sp_z),
Range(1, (_n + 1) *
(_n + 1), 1),
), _n + 1 +
1, 1) if sp_j == 0 else Apply((sp_below: integer) => Apply(
(sp_prev: list<integer>) => Map(Function(Apply(
(sp_a: integer) => Apply((sp_c: integer) => Fold(Function(sp_s +
(sp_prev[sp_a2 *
(_n + 1) +
(sp_c -
(sp_below - sp_a2 +
1)) +
1] if sp_c >=
sp_below - sp_a2 +
1 else 0), sp_s, sp_a2), 0, Range(1, Min(sp_below, sp_a), 1)) if sp_a >= 1 &&
sp_a <=
sp_below + 1 else 0, sp_i %
(_n + 1)),
(sp_i -
sp_i %
(_n + 1)) /
(_n + 1),
), sp_i), Range(0, (_n + 1) *
(_n + 1) -
1, 1)),
Drop(sp_h, (sp_j - 1) *
(_n + 1) *
(_n + 1)),
), sp_lam[sp_rows - sp_j +
1]),
), sp_h, sp_j), [], Range(0, sp_rows - 1, 1)),
),
Fold(
Function(Apply((sp_g: list<integer>) => Apply((sp_bt: integer) => Join([sp_st[1] +
sp_g[(0 if sp_t == 1 else 1) *
(_n + 1) + _n + 1] +
Fold(Function(sp_x +
Fold(Function(sp_w +
Apply((sp_k: integer) => Fold(
Function(sp_u +
Fold(Function(sp_v +
sp_g[sp_a *
(_n + 1) + sp_c + 1] *
_tables[(_n - sp_c -
sp_k) * _n * _n +
(sp_b - 1) *
_n +
sp_o], sp_v, sp_c), 0, Range(0, _n - sp_k, 1)), sp_u, sp_a),
0,
Range(0 if sp_t == 1 else sp_b, 0 if sp_t == 1 else Min(sp_o + 1, _n), 1),
), sp_o - sp_b +
1), sp_w, sp_b), 0, Range(1, sp_o, 1)), sp_x, sp_o), 0, Range(1, sp_bt - 1, 1))], Map(
Function(Apply((sp_a1: integer) => Apply(
(sp_c1: integer) => Apply((sp_k: integer) => Fold(
Function(sp_s +
sp_g[sp_a *
(_n + 1) +
(sp_c1 - sp_k) +
1], sp_s, sp_a),
0,
Range(0 if sp_t == 1 else sp_a1, 0 if sp_t == 1 else Min(sp_bt + 1, _n), 1),
) if sp_c1 >= sp_k else 0, sp_bt - sp_a1 +
1) if sp_a1 >= 1 &&
sp_a1 <= sp_bt else 0,
sp_i %
(_n + 1),
), (sp_i -
sp_i %
(_n + 1)) /
(_n + 1)), sp_i),
Range(0, (_n + 1) *
(_n + 1) -
1, 1),
)), sp_lam[sp_t]), Drop(sp_st, 1)), sp_st, sp_t),
Join([0], ReplaceAt(Map(
Function(0, sp_z),
Range(1, (_n + 1) *
(_n + 1), 1),
), 1, 1)),
Range(1, sp_rows, 1),
),
), Length(sp_lam)), _x[2]), _x[1])valid(_n, _x)
Apply((sv_lam: list<integer>) => Length(_x[2]) <= Length(sv_lam) && Fold(
Function(ok_sv_i &&
sv_lam[sv_i] >= 1, ok_sv_i, sv_i),
True,
Range(1, Length(sv_lam), 1),
) &&
Fold(
Function(ok_sv_j && sv_lam[sv_j] <=
sv_lam[sv_j - 1], ok_sv_j, sv_j),
True,
Range(2, Length(sv_lam), 1),
) && Fold(
Function(
ok_sv_k && _x[2][sv_k] >=
1,
ok_sv_k,
sv_k,
),
True,
Range(1, Length(_x[2]), 1),
) && Fold(
Function(
ok_sv_l && _x[2][sv_l] <=
_x[2][sv_l - 1],
ok_sv_l,
sv_l,
),
True,
Range(
2,
Length(_x[2]),
1,
),
) && Fold(
Function(
ok_sv_m &&
_x[2][sv_m] <
sv_lam[sv_m],
ok_sv_m,
sv_m,
),
True,
Range(
1,
Length(_x[2]),
1,
),
) && (Length(sv_lam) ==
0 || Length(_x[2]) <
Length(sv_lam)) &&
Fold(
Function(ok_sv_o && _x[2][sv_o] <=
sv_lam[sv_o + 1], ok_sv_o, sv_o),
True,
Range(1, Length(_x[2]), 1),
) && Fold(
Function(
sv_x + sv_lam[sv_p],
sv_x,
sv_p,
),
0,
Range(1, Length(sv_lam), 1),
) - Fold(
Function(sv_y +
_x[2][sv_q], sv_y, sv_q),
0,
Range(1, Length(_x[2]), 1),
) == _n, _x[1]) if Length(_x) == 2 else Falsetables(_n)
Fold(Function(Join(
sk_t,
Fold(Function(ReplaceAt(
sk_row,
sk_c + 1,
Apply((sk_a: integer) => Apply(
(sk_b: integer) => 0 if sk_a > sk_b else Fold(
Function(sk_x +
Fold(
Function(sk_y +
sk_t[(sk_s - sk_b2 -
(1 - sk_a2)) *
Max(_n, 0) *
Max(_n, 0) +
(sk_a2 - 1) *
_n +
(sk_b2 - 1) +
1], sk_y, sk_a2),
0,
Range(Max(1, sk_b2 - sk_s +
1), Min(sk_a, sk_b2), 1),
), sk_x, sk_b2),
0,
Range(Max(sk_a - 1, 1), sk_b, 1),
),
sk_c %
_n +
1,
), (sk_c -
sk_c %
_n) /
_n +
1),
), sk_row, sk_c), Map(
Function(
0,
sk_z,
),
Range(
0,
Max(
_n,
0,
) *
Max(
_n,
0,
) - 1,
1,
),
), Range(
0,
Max(
_n,
0,
) *
Max(
_n,
0,
) - 1,
1,
)),
), sk_t, sk_s), Fold(
Function(ReplaceAt(
sk_row,
sk_c + 1,
1 if sk_c < _n else 0,
), sk_row, sk_c),
Map(
Function(0, sk_z),
Range(
0,
Max(_n, 0) * Max(_n, 0) - 1,
1,
),
),
Range(0, Max(_n, 0) * Max(_n, 0) - 1, 1),
), Range(1, Max(_n, 0) + 1 - 1, 1))Enumeration
Examples
1 more kept as data, checked against the oraclesAbout
| Examples | 3 |
|---|---|
| Crosswalk | SageMath |
See also: IntegerPartitions, Count, At