BoxedPlanePartitions
Plane partitions of any size fitting in an box — at most rows, each at most long, entries at most — as a lazy indexed family.
SageMath
PlanePartitions([a, b, c])BoxedPlanePartitions(a, b, c)the plane partitions fitting an box.Typed signatures
| Type | Package | Applies |
|---|---|---|
(integer<0..>, integer<0..>, integer<0..>) -> indexed_collection<list<list<integer>>> | combinatorics | always |
Details
- A lazy indexed collection, exact and closed-form by MacMahon's box formula: — .
- Each element is the array's rows, PlanePartitions's ragged carrier: entries weakly decrease along every row and down every column, with trailing zeros trimmed rather than stored.
- Unranked in shape-then-entries order, same as PlanePartitions. A rank is found by walking a table over the rows a box allows (counting what each row starts), so
Atanswers in boxes whose whole list is far too long to build, up to about (267,227,532 partitions); past that a call is refused as too long, and past partitions only the count answers.
Definition
Epsil, as the implementation runs it.
count(_a, _b, _c)
Apply((bp_A: integer) => Apply((bp_B: integer) => Apply(
(bp_C: integer) => Apply((bp_N: integer) => Fold(
Function(Apply(
(bc_e: integer) => Fold(
Function(bc_w * bc_p, bc_w, bc_k),
bc_acc,
Range(1, bc_e, 1),
),
Apply((bc_st_init: list<integer>) => Fold(
(bc_st: list<integer>, bc_j) => Apply(
(bc_st_next: list<integer>) => bc_st_next,
bc_st if bc_st[2] >
bp_A + bp_B + bp_C -
1 else Apply((bc_q: integer) => [bc_st[1] +
(Fold(Function(bp_s105 +
Max(0, Min(bp_A, bp_x106 - 1) -
Max(1, bp_x106 - bp_B) +
1) *
(1 if (bp_x106 + bp_C -
1) %
bc_q ==
0 else 0), bp_s105, bp_x106), 0, Range(2, bp_A + bp_B, 1)) -
Fold(Function(bp_s107 +
Max(0, Min(bp_A, bp_x108 - 1) -
Max(1, bp_x108 - bp_B) +
1) *
(1 if (bp_x108 - 1) %
bc_q ==
0 else 0), bp_s107, bp_x108), 0, Range(2, bp_A + bp_B, 1))), bc_q * bc_p], bc_st[2]),
),
bc_st_init,
Range(1, bp_A + bp_B + bp_C -
1, 1),
), [0, bc_p])[1],
) if Fold(
Function(ok_bc_d &&
bc_p % bc_d !=
0, ok_bc_d, bc_d),
True,
Range(2, bc_p - 1, 1),
) else bc_acc, bc_acc, bc_p),
1,
Range(2, bp_A + bp_B + bp_C -
1, 1),
), Binomial(bp_B + bp_C, bp_B)),
0 if _a < 1 ||
_b < 1 || _c < 1 else _c,
), 0 if _a < 1 ||
_b < 1 || _c < 1 else _b), 0 if _a <
1 ||
_b <
1 ||
_c <
1 else _a)unrank(_a, _b, _c, _r)
Apply((bp_A: integer) => Apply((bp_B: integer) => Apply((bp_C: integer) => Apply((bp_N: integer) => Apply(
(bp_p142: list<integer>) => Apply((bp_lens46: list<integer>) => Apply((bp_rows41: integer) => Apply(
(bp_wl43: list<integer>) => Apply(
(bp_ch44: list<integer>) => Map(Function(Map(
Function(_tables[(bp_A + 1) *
bp_N + bp_ch44[bp_t14] *
(bp_B + 1) + bp_j49 + 1], bp_j49),
Range(1, _tables[(bp_A + 1) *
bp_N + bp_ch44[bp_t14] *
(bp_B + 1) + 0 + 1], 1),
), bp_t14), Range(1, bp_rows41, 1)),
Drop(Apply(
(bp_q38_init: list<integer>) => Fold((bp_q38: list<integer>, bp_u39) => Apply(
(bp_q38_next: list<integer>) => bp_q38_next,
bp_q38 if bp_u39 > bp_rows41 else Apply(
(bp_row45: list<integer>) => Join([bp_row45[1], bp_row45[2] - 1], ReplaceAt(Drop(bp_q38, 2), bp_u39, bp_row45[2] - 1)),
Apply((bp_pk47_init: list<integer>) => Fold(
(bp_pk47: list<integer>, bp_w40) => Apply(
(bp_pk47_next: list<integer>) => bp_pk47_next,
bp_pk47 if bp_pk47[2] > 0 else Apply(
(bp_ways48: integer) => [bp_pk47[1], bp_w40 + 1] if bp_pk47[1] < bp_ways48 else [bp_pk47[1] - bp_ways48, 0],
bp_wl43[(bp_rows41 - bp_u39) *
bp_N + bp_w40 + 1],
) if (1 if 0 ==
Fold(Function(bp_a50 +
(1 if _tables[(bp_A + 1) *
bp_N + bp_w40 *
(bp_B + 1) + bp_j51 + 1] >
_tables[(bp_A + 1) *
bp_N + bp_q38[2] *
(bp_B + 1) + bp_j51 + 1] else 0), bp_a50, bp_j51), 0, Range(1, _tables[(bp_A + 1) *
bp_N + bp_w40 *
(bp_B + 1) + 0 + 1], 1)) else 0) ==
1 else bp_pk47,
),
bp_pk47_init,
Range(
Binomial(bp_lens46[bp_u39] - 1 +
bp_C, bp_lens46[bp_u39] - 1),
Binomial(bp_lens46[bp_u39] - 1 +
bp_C, bp_lens46[bp_u39] - 1) +
Binomial(bp_lens46[bp_u39] +
(bp_C - 1), bp_lens46[bp_u39]) -
1,
1,
),
), [bp_q38[1], 0]),
),
), bp_q38_init, Range(1, bp_A, 1)),
Join([bp_p142[1], bp_N - 1], Map(Function(0, bp_z52), Range(1, bp_A, 1))),
), 2),
),
Apply((bp_a55_init: list<integer>) => Fold((bp_a55: list<integer>, bp_j56) => Apply(
(bp_a55_next: list<integer>) => bp_a55_next,
Join(
bp_a55,
Map(Function(1 if _tables[(bp_A + 1) *
bp_N + bp_i57 *
(bp_B + 1) + 0 + 1] ==
bp_lens46[bp_rows41] else 0, bp_i57), Range(0, bp_N - 1, 1)) if bp_j56 == 0 else Apply((bp_p58: list<integer>) => Map(Function(Fold(
Function(bp_s59 +
(bp_p58[bp_x60 + 1] *
(1 if 0 ==
Fold(Function(bp_a61 +
(1 if _tables[(bp_A + 1) *
bp_N + bp_x60 *
(bp_B + 1) + bp_j62 + 1] >
_tables[(bp_A + 1) *
bp_N + bp_i57 *
(bp_B + 1) + bp_j62 + 1] else 0), bp_a61, bp_j62), 0, Range(1, _tables[(bp_A + 1) *
bp_N + bp_x60 *
(bp_B + 1) + 0 + 1], 1)) else 0) if bp_p58[bp_x60 + 1] >
0 else 0), bp_s59, bp_x60),
0,
Range(Binomial(bp_lens46[bp_rows41 - bp_j56 +
1] -
1 +
bp_C, bp_lens46[bp_rows41 - bp_j56 +
1] -
1), Binomial(bp_lens46[bp_rows41 - bp_j56 +
1] -
1 +
bp_C, bp_lens46[bp_rows41 - bp_j56 +
1] -
1) +
Binomial(bp_lens46[bp_rows41 - bp_j56 +
1] +
(bp_C - 1), bp_lens46[bp_rows41 - bp_j56 +
1]) -
1, 1),
) if _tables[(bp_A + 1) *
bp_N + bp_i57 *
(bp_B + 1) + 0 + 1] ==
bp_lens46[bp_rows41 - bp_j56] else 0, bp_i57), Range(0, bp_N - 1, 1)), Drop(bp_a55, (bp_j56 - 1) *
bp_N)),
),
), bp_a55_init, Range(0, bp_rows41 - 1, 1)), []),
), Fold(Function(bp_s53 +
(1 if bp_lens46[bp_x54] > 0 else 0), bp_s53, bp_x54), 0, Range(1, bp_A, 1))), Drop(bp_p142, 2 + bp_N)),
Apply(
(bp_st13_init: list<integer>) => Fold((bp_st13: list<integer>, bp_t14) => Apply(
(bp_st13_next: list<integer>) => bp_st13_next,
bp_st13 if bp_st13[2] == 0 else Apply(
(bp_g16: list<integer>) => Apply((bp_ls17: list<integer>) => Apply((bp_cap15: integer) => Apply(
(bp_end18: integer) => Join([bp_st13[1], 0], bp_g16, bp_ls17) if bp_st13[1] < bp_end18 else Apply(
(bp_fd19: list<integer>) => Join(
[bp_fd19[1], bp_fd19[2]],
Map(Function(Fold(
Function(bp_s32 +
(bp_g16[bp_x33 + 1] *
(1 if 0 ==
Fold(Function(bp_a34 +
(1 if _tables[(bp_A + 1) *
bp_N + bp_i31 *
(bp_B + 1) + bp_j35 + 1] >
_tables[(bp_A + 1) *
bp_N + bp_x33 *
(bp_B + 1) + bp_j35 + 1] else 0), bp_a34, bp_j35), 0, Range(1, _tables[(bp_A + 1) *
bp_N + bp_i31 *
(bp_B + 1) + 0 + 1], 1)) else 0) if bp_g16[bp_x33 + 1] >
0 else 0), bp_s32, bp_x33),
0,
Range(Binomial(bp_cap15 - 1 +
bp_C, bp_cap15 - 1), Binomial(bp_cap15 - 1 +
bp_C, bp_cap15 - 1) +
Binomial(bp_cap15 +
(bp_C - 1), bp_cap15) -
1, 1),
) if _tables[(bp_A + 1) *
bp_N + bp_i31 *
(bp_B + 1) + 0 + 1] ==
bp_fd19[2] else 0, bp_i31), Range(0, bp_N - 1, 1)),
ReplaceAt(bp_ls17, bp_t14, bp_fd19[2]),
),
Apply((bp_f22_init: list<integer>) => Fold((bp_f22: list<integer>, bp_lam20) => Apply(
(bp_f22_next: list<integer>) => bp_f22_next,
bp_f22 if bp_f22[2] > 0 else Apply(
(bp_sz21: integer) => [bp_f22[1], bp_lam20] if bp_f22[1] < bp_sz21 else [bp_f22[1] - bp_sz21, 0],
Fold(Function(bp_s23 +
_tables[(bp_A - bp_t14) *
bp_N + bp_x24 + 1] *
Fold(Function(bp_s25 +
(bp_g16[bp_x26 + 1] *
(1 if 0 ==
Fold(Function(bp_a27 +
(1 if _tables[(bp_A + 1) *
bp_N + bp_x24 *
(bp_B + 1) + bp_j28 + 1] >
_tables[(bp_A + 1) *
bp_N + bp_x26 *
(bp_B + 1) + bp_j28 + 1] else 0), bp_a27, bp_j28), 0, Range(1, _tables[(bp_A + 1) *
bp_N + bp_x24 *
(bp_B + 1) + 0 + 1], 1)) else 0) if bp_g16[bp_x26 + 1] >
0 else 0), bp_s25, bp_x26), 0, Range(Binomial(bp_cap15 - 1 +
bp_C, bp_cap15 - 1), Binomial(bp_cap15 - 1 +
bp_C, bp_cap15 - 1) +
Binomial(bp_cap15 +
(bp_C - 1), bp_cap15) -
1, 1)), bp_s23, bp_x24), 0, Range(Binomial(bp_lam20 - 1 +
bp_C, bp_lam20 - 1), Binomial(bp_lam20 - 1 +
bp_C, bp_lam20 - 1) +
Binomial(bp_lam20 +
(bp_C - 1), bp_lam20) -
1, 1)),
),
), bp_f22_init, Range(1, bp_cap15, 1)), [bp_st13[1] - bp_end18, 0]),
),
Fold(Function(bp_s29 +
bp_g16[bp_x30 + 1], bp_s29, bp_x30), 0, Range(0, bp_N - 1, 1)),
), bp_st13[2]), Drop(bp_st13, 2 + bp_N)),
Take(Drop(bp_st13, 2), bp_N),
),
), bp_st13_init, Range(1, bp_A, 1)),
Join(
[_r, bp_B],
Map(
Function(1 if bp_i36 ==
bp_N - 1 else 0, bp_i36),
Range(0, bp_N - 1, 1),
),
Map(Function(0, bp_z37), Range(1, bp_A, 1)),
),
),
), Binomial(bp_B + bp_C, bp_B)), 0 if _a < 1 ||
_b < 1 ||
_c < 1 else _c), 0 if _a < 1 ||
_b < 1 ||
_c < 1 else _b), 0 if _a < 1 ||
_b < 1 ||
_c < 1 else _a)rank(_a, _b, _c, _x)
Apply((bp_A: integer) => Apply((bp_B: integer) => Apply((bp_C: integer) => Apply(
(bp_N: integer) => 0 if Length(_x) == 0 else Apply((bp_k69: integer) => Apply((bp_ls68: list<integer>) => Apply(
(bp_wl70: list<integer>) => Apply(
(bp_st88_init: list<integer>) => Fold((bp_st88: list<integer>, bp_t64) => Apply(
(bp_st88_next: list<integer>) => bp_st88_next,
Apply(
(bp_ix71: integer) => [bp_st88[1] +
Fold(Function(bp_s93 +
(bp_wl70[(bp_k69 - bp_t64) *
bp_N + bp_x94 + 1] if (1 if 0 ==
Fold(Function(bp_a95 +
(1 if _tables[(bp_A + 1) *
bp_N + bp_x94 *
(bp_B + 1) + bp_j96 + 1] >
_tables[(bp_A + 1) *
bp_N + bp_st88[2] *
(bp_B + 1) + bp_j96 + 1] else 0), bp_a95, bp_j96), 0, Range(1, _tables[(bp_A + 1) *
bp_N + bp_x94 *
(bp_B + 1) + 0 + 1], 1)) else 0) ==
1 else 0), bp_s93, bp_x94), 0, Range(Binomial(bp_ls68[bp_t64] - 1 +
bp_C, bp_ls68[bp_t64] - 1), bp_ix71 - 1, 1)), bp_ix71],
Fold(
Function(bp_n90 if 0 ==
Fold(Function(bp_s91 +
(1 if _tables[(bp_A + 1) *
bp_N + bp_n90 *
(bp_B + 1) + bp_x92 + 1] !=
_x[bp_t64][bp_x92] else 0), bp_s91, bp_x92), 0, Range(1, bp_ls68[bp_t64], 1)) else bp_a89, bp_a89, bp_n90),
0,
Range(
Binomial(bp_ls68[bp_t64] - 1 +
bp_C, bp_ls68[bp_t64] - 1),
Binomial(bp_ls68[bp_t64] - 1 +
bp_C, bp_ls68[bp_t64] - 1) +
Binomial(bp_ls68[bp_t64] +
(bp_C - 1), bp_ls68[bp_t64]) -
1,
1,
),
),
),
), bp_st88_init, Range(1, bp_k69, 1)),
[Apply(
(bp_st63_init: list<integer>) => Fold((bp_st63: list<integer>, bp_t64) => Apply(
(bp_st63_next: list<integer>) => bp_st63_next,
Apply((bp_g65: list<integer>) => Apply(
(bp_cap66: integer) => Apply((bp_lam67: integer) => Join([bp_st63[1] +
Fold(Function(bp_s72 +
bp_g65[bp_x73 + 1], bp_s72, bp_x73), 0, Range(0, bp_N - 1, 1)) +
Fold(Function(bp_s74 +
Fold(
Function(bp_s76 +
_tables[(bp_A - bp_t64) *
bp_N + bp_x77 + 1] *
Fold(
Function(bp_s78 +
(bp_g65[bp_x79 + 1] *
(1 if 0 ==
Fold(Function(bp_a80 +
(1 if _tables[(bp_A + 1) *
bp_N + bp_x77 *
(bp_B + 1) + bp_j81 + 1] >
_tables[(bp_A + 1) *
bp_N + bp_x79 *
(bp_B + 1) + bp_j81 + 1] else 0), bp_a80, bp_j81), 0, Range(1, _tables[(bp_A + 1) *
bp_N + bp_x77 *
(bp_B + 1) + 0 + 1], 1)) else 0) if bp_g65[bp_x79 + 1] >
0 else 0), bp_s78, bp_x79),
0,
Range(Binomial(bp_cap66 - 1 +
bp_C, bp_cap66 - 1), Binomial(bp_cap66 - 1 +
bp_C, bp_cap66 - 1) +
Binomial(bp_cap66 +
(bp_C - 1), bp_cap66) -
1, 1),
), bp_s76, bp_x77),
0,
Range(Binomial(bp_x75 - 1 +
bp_C, bp_x75 - 1), Binomial(bp_x75 - 1 +
bp_C, bp_x75 - 1) +
Binomial(bp_x75 +
(bp_C - 1), bp_x75) -
1, 1),
), bp_s74, bp_x75), 0, Range(1, bp_lam67 - 1, 1))], Map(Function(Fold(
Function(bp_s83 +
(bp_g65[bp_x84 + 1] *
(1 if 0 ==
Fold(Function(bp_a85 +
(1 if _tables[(bp_A + 1) *
bp_N + bp_i82 *
(bp_B + 1) + bp_j86 + 1] >
_tables[(bp_A + 1) *
bp_N + bp_x84 *
(bp_B + 1) + bp_j86 + 1] else 0), bp_a85, bp_j86), 0, Range(1, _tables[(bp_A + 1) *
bp_N + bp_i82 *
(bp_B + 1) + 0 + 1], 1)) else 0) if bp_g65[bp_x84 + 1] >
0 else 0), bp_s83, bp_x84),
0,
Range(Binomial(bp_cap66 - 1 +
bp_C, bp_cap66 - 1), Binomial(bp_cap66 - 1 +
bp_C, bp_cap66 - 1) +
Binomial(bp_cap66 +
(bp_C - 1), bp_cap66) -
1, 1),
) if _tables[(bp_A + 1) *
bp_N + bp_i82 *
(bp_B + 1) + 0 + 1] ==
bp_lam67 else 0, bp_i82), Range(0, bp_N - 1, 1))), bp_ls68[bp_t64]),
bp_B if bp_t64 == 1 else bp_ls68[bp_t64 - 1],
), Drop(bp_st63, 1)),
), bp_st63_init, Range(1, bp_k69, 1)),
Join([0], Map(Function(1 if bp_i87 ==
bp_N - 1 else 0, bp_i87), Range(0, bp_N - 1, 1))),
)[1], bp_N - 1],
)[1],
Apply((bp_a97_init: list<integer>) => Fold((bp_a97: list<integer>, bp_j98) => Apply(
(bp_a97_next: list<integer>) => bp_a97_next,
Join(
bp_a97,
Map(Function(1 if _tables[(bp_A + 1) *
bp_N + bp_i99 *
(bp_B + 1) + 0 + 1] ==
bp_ls68[bp_k69] else 0, bp_i99), Range(0, bp_N - 1, 1)) if bp_j98 == 0 else Apply(
(bp_p100: list<integer>) => Map(Function(Fold(
Function(bp_s101 +
(bp_p100[bp_x102 + 1] *
(1 if 0 ==
Fold(Function(bp_a103 +
(1 if _tables[(bp_A + 1) *
bp_N + bp_x102 *
(bp_B + 1) + bp_j104 + 1] >
_tables[(bp_A + 1) *
bp_N + bp_i99 *
(bp_B + 1) + bp_j104 + 1] else 0), bp_a103, bp_j104), 0, Range(1, _tables[(bp_A + 1) *
bp_N + bp_x102 *
(bp_B + 1) + 0 + 1], 1)) else 0) if bp_p100[bp_x102 + 1] >
0 else 0), bp_s101, bp_x102),
0,
Range(Binomial(bp_ls68[bp_k69 - bp_j98 +
1] -
1 +
bp_C, bp_ls68[bp_k69 - bp_j98 +
1] -
1), Binomial(bp_ls68[bp_k69 - bp_j98 +
1] -
1 +
bp_C, bp_ls68[bp_k69 - bp_j98 +
1] -
1) +
Binomial(bp_ls68[bp_k69 - bp_j98 +
1] +
(bp_C - 1), bp_ls68[bp_k69 - bp_j98 +
1]) -
1, 1),
) if _tables[(bp_A + 1) *
bp_N + bp_i99 *
(bp_B + 1) + 0 + 1] ==
bp_ls68[bp_k69 - bp_j98] else 0, bp_i99), Range(0, bp_N - 1, 1)),
Drop(bp_a97, (bp_j98 - 1) *
bp_N),
),
),
), bp_a97_init, Range(0, bp_k69 - 1, 1)), []),
), Map(Function(Length(_x[bp_t64]), bp_t64), Range(1, bp_k69, 1))), Length(_x)),
Binomial(bp_B + bp_C, bp_B),
), 0 if _a < 1 ||
_b < 1 ||
_c < 1 else _c), 0 if _a < 1 ||
_b < 1 ||
_c < 1 else _b), 0 if _a < 1 ||
_b < 1 ||
_c < 1 else _a)valid(_a, _b, _c, _x)
(Fold(Function(
ok_bp_vu && Fold(
Function(ok_bp_vj && _x[bp_vu][bp_vj] >= 1 &&
_x[bp_vu][bp_vj] <=
(0 if _a < 1 ||
_b < 1 || _c < 1 else _c) &&
(True if bp_vj == 1 else _x[bp_vu][bp_vj] <=
_x[bp_vu][bp_vj - 1]) &&
(True if bp_vu == 1 else _x[bp_vu][bp_vj] <=
_x[bp_vu - 1][bp_vj]), ok_bp_vj, bp_vj),
True,
Range(1, Length(_x[bp_vu]), 1),
),
ok_bp_vu,
bp_vu,
), True, Range(1, Length(_x), 1)) if Fold(
Function(ok_bp_vt &&
((True if bp_vt ==
1 else Length(_x[bp_vt]) <=
Length(_x[bp_vt - 1])) if Length(_x[bp_vt]) >= 1 &&
Length(_x[bp_vt]) <=
(0 if _a < 1 ||
_b < 1 ||
_c < 1 else _b) else False), ok_bp_vt, bp_vt),
True,
Range(1, Length(_x), 1),
) else False) if Length(_x) <=
(0 if _a <
1 ||
_b <
1 ||
_c <
1 else _a) else Falsetables(_a, _b, _c)
Apply((bp_A: integer) => Apply((bp_B: integer) => Apply(
(bp_C: integer) => Apply((bp_N: integer) => Apply(
(bp_rows: list<integer>) => Join(Fold(
Function(Join(
bu_t,
Fold(
Function(ReplaceAt(
bu_row,
bu_c + 1,
1 +
Fold(
Function(bp_s9 +
(1 if 0 ==
Fold(
Function(bp_a11 +
(1 if bp_rows[0 + bp_x10 *
(bp_B + 1) + bp_j12 + 1] >
bp_rows[0 + bu_c *
(bp_B + 1) + bp_j12 + 1] else 0), bp_a11, bp_j12),
0,
Range(1, bp_rows[0 + bp_x10 *
(bp_B + 1) + 0 + 1], 1),
) else 0) *
bu_t[(bu_s - 1) *
bp_N + bp_x10 + 1], bp_s9, bp_x10),
0,
Range(1, Binomial(bp_rows[0 + bu_c *
(bp_B + 1) + 0 + 1] +
bp_C, bp_rows[0 + bu_c *
(bp_B + 1) + 0 + 1]) -
1, 1),
),
), bu_row, bu_c),
Map(Function(0, bu_z), Range(0, bp_N - 1, 1)),
Range(0, bp_N - 1, 1),
),
), bu_t, bu_s),
Fold(
Function(ReplaceAt(bu_row, bu_c + 1, 1), bu_row, bu_c),
Map(Function(0, bu_z), Range(0, bp_N - 1, 1)),
Range(0, bp_N - 1, 1),
),
Range(1, bp_A + 1 -
1, 1),
), bp_rows),
Apply(
(bp_a0_init: list<integer>) => Fold(
(bp_a0: list<integer>, bp_i1) => Apply(
(bp_a0_next: list<integer>) => bp_a0_next,
Join(
bp_a0,
Apply(
(bp_p2: list<integer>) => Apply(
(bp_l3: integer) => ReplaceAt(Apply(
(bp_c6_init: list<integer>) => Fold((bp_c6: list<integer>, bp_k5) => Apply(
(bp_c6_next: list<integer>) => bp_c6_next,
ReplaceAt(bp_c6, bp_k5 + 1, (1 if bp_k5 <=
bp_p2[1] + 1 else 0) if bp_l3 == 0 else bp_p2[bp_k5 + 1] if bp_k5 < bp_l3 else bp_p2[bp_k5 + 1] +
1 if bp_k5 == bp_l3 else 1 if bp_k5 <= bp_p2[1] else 0),
), bp_c6_init, Range(1, bp_B, 1)),
Map(Function(0, bp_z7), Range(1, bp_B + 1, 1)),
), 1, bp_p2[1] + 1 if bp_l3 == 0 else bp_p2[1]),
Fold(Function(bp_j4 if bp_j4 <= bp_p2[1] &&
bp_p2[bp_j4 + 1] <
(bp_C if bp_j4 == 1 else bp_p2[bp_j4]) else bp_l3, bp_l3, bp_j4), 0, Range(1, bp_B, 1)),
),
Take(Drop(bp_a0, (bp_i1 - 1) *
(bp_B + 1)), bp_B + 1),
),
),
),
bp_a0_init,
Range(1, bp_N - 1, 1),
),
Map(
Function(0, bp_z8),
Range(1, bp_B + 1, 1),
),
),
), Binomial(bp_B + bp_C, bp_B)),
0 if _a < 1 ||
_b < 1 || _c < 1 else _c,
), 0 if _a < 1 ||
_b < 1 || _c < 1 else _b), 0 if _a <
1 ||
_b <
1 ||
_c <
1 else _a)Enumeration
Examples
1 more kept as data, checked against the oraclesAbout
| Examples | 3 |
|---|---|
| Crosswalk | SageMath |
See also: PlanePartitions, Count, At