def apply(n, Q=None):
if Q is None:
Q, w, x = mapping.Qu2v.predefined_symbols(n)
else:
x = Q.definition.function.variable
P_quote = Symbol("P'", definition=conditionset(x[:n + 1], Equality(x[:n].set_comprehension(), Interval(0, n - 1, integer=True)) & Equality(x[n], n)))
t = Q.definition.variable
return Equality(Abs(Q[t]), Abs(P_quote))
def apply(n):
x = Symbol.x(shape=(oo, ), integer=True, nonnegative=True)
return Equality(
abs(
conditionset(
x[:n],
Equality(x[:n].set_comprehension(),
Interval(0, n - 1, integer=True)))), factorial(n))
def prove(Eq):
n = Symbol.n(domain=Interval(2, oo, integer=True))
S = Symbol.S(dtype=dtype.integer * n)
x = Symbol.x(**S.element_symbol().dtype.dict)
i = Symbol.i(integer=True)
j = Symbol.j(integer=True)
given = [
ForAll[j:1:n - 1, x:S](Contains(
LAMBDA[i:n](Piecewise((x[0], Equality(i, j)),
(x[j], Equality(i, 0)), (x[i], True))), S)),
ForAll[x:S](Equality(abs(x.set_comprehension()), n))
]
Eq << apply(given)
Eq << discrete.combinatorics.permutation.adjacent.swap2.general.apply(
Eq[0])
Eq.permutation = discrete.combinatorics.permutation.adjacent.swapn.permutation.apply(
Eq[-1])
Eq << Eq.permutation.limits[0][1].this.definition
Eq << discrete.combinatorics.permutation.factorial.definition.apply(n)
Eq << Eq[-1].this.lhs.arg.limits_subs(Eq[-1].lhs.arg.variable,
Eq[-2].rhs.variable)
Eq <<= Eq[-1] & Eq[-2].abs()
F = Function.F(nargs=(), dtype=dtype.integer * n)
F.eval = lambda e: conditionset(x, Equality(x.set_comprehension(), e), S)
e = Symbol.e(dtype=dtype.integer)
Eq << Subset(F(e), S, plausible=True)
Eq << Eq[-1].this.lhs.definition
Eq << sets.subset.forall.imply.forall.apply(Eq[-1], Eq.permutation)
Eq.forall_x = ForAll(Contains(Eq[-1].lhs, F(e)),
*Eq[-1].limits,
plausible=True)
Eq << Eq.forall_x.definition.split()
P = Eq[-1].limits[0][1]
Eq << sets.imply.conditionset.apply(P)
Eq << Eq[-1].apply(sets.equality.imply.equality.permutation, x)
Eq.equality_e = Eq[-3] & Eq[-1]
Eq << sets.imply.conditionset.apply(F(e)).reversed
def prove(Eq):
k = Symbol.k(integer=True, positive=True)
n = Symbol.n(integer=True, positive=True)
Eq << apply(n, k)
Eq.stirling2 = Eq[0].lhs.this.definition
Eq.stirling0 = Eq[0].rhs.args[1].this.definition
Eq.stirling1 = Eq[0].rhs.args[0].args[1].this.definition
s2 = Symbol.s2(definition=Eq.stirling2.rhs.arg)
Eq << s2.this.definition
s2_quote = Symbol.s_quote_2(definition=Eq.stirling2.rhs.arg.limits[0][1])
Eq.stirling2 = Eq.stirling2.subs(Eq[-1].reversed)
s0 = Symbol.s0(definition=Eq.stirling0.rhs.arg)
Eq << s0.this.definition
s0_quote = Symbol.s_quote_0(definition=Eq.stirling0.rhs.arg.limits[0][1])
Eq.stirling0 = Eq.stirling0.subs(Eq[-1].reversed)
s1 = Symbol.s1(definition=Eq.stirling1.rhs.arg)
Eq << s1.this.definition
s1_quote = Symbol("s'_1", definition=Eq.stirling1.rhs.arg.limits[0][1])
Eq.stirling1 = Eq.stirling1.subs(Eq[-1].reversed)
e = Symbol.e(dtype=dtype.integer.set)
Eq << s2.this.bisect(conditionset(e, Contains({n}, e), s2))
Eq.s2_abs = Eq[-1].abs()
Eq.s2_abs_plausible = Eq[0].subs(Eq.stirling2, Eq.stirling0, Eq.stirling1)
Eq << discrete.combinatorics.stirling.second.mapping.s2_A.apply(n, k, s2)
A = Eq[-1].rhs.function.base
Eq << discrete.combinatorics.stirling.second.mapping.s2_B.apply(n, k, s2)
B = Eq[-1].rhs
Eq.s2_abs = Eq.s2_abs.subs(Eq[-1], Eq[-2])
Eq << discrete.combinatorics.stirling.second.mapping.s0_B.apply(
n, k, s0, B)
Eq << Eq.s2_abs.subs(Eq[-1].reversed)
Eq.A_union_abs = Eq.s2_abs_plausible.subs(Eq[-1])
Eq << discrete.combinatorics.stirling.second.nonoverlapping.apply(n, k, A)
Eq << Eq.A_union_abs.subs(Eq[-1])
Eq << discrete.combinatorics.stirling.second.mapping.s1_Aj.apply(
n, k, s1, A).reversed
Eq << Eq[-1].sum(*Eq[-2].lhs.limits)
def apply(n):
Q, w, x = mapping.Qu2v.predefined_symbols(n)
Pn1 = Symbol("P_{n+1}",
definition=conditionset(
x[:n + 1],
Equality(x[:n + 1].set_comprehension(),
Interval(0, n, integer=True))))
t = Q.definition.variable
return Equality(UNION[t](Q[t]), Pn1)
def apply(n, P_quote=None):
Q, w, x = mapping.Qu2v.predefined_symbols(n)
if P_quote is None:
P_quote = Symbol("P'",
definition=conditionset(
x[:n + 1],
Equality(x[:n].set_comprehension(),
Interval(0, n - 1, integer=True))
& Equality(x[n], n)))
return Equality(Q[n], P_quote)
def predefined_symbols(n):
x = Symbol.x(shape=(oo, ), integer=True, nonnegative=True)
t = Symbol.t(integer=True)
Q = Symbol.Q(definition=LAMBDA[t:n + 1](conditionset(
x[:n + 1],
Equality(x[:n + 1].set_comprehension(), Interval(0, n, integer=True))
& Equality(x[n], t))))
j = Symbol.j(integer=True)
i = Symbol.i(integer=True)
w = Symbol.w(definition=LAMBDA[j:n + 1, i:n + 1](Swap(n + 1, i, j)))
return Q, w, x
def prove(Eq):
n = Symbol.n(integer=True, positive=True)
x = Symbol.x(shape=(oo, ), integer=True, nonnegative=True)
P = Symbol.P(definition=conditionset(
x[:n], Equality(x[:n].set, Interval(0, n - 1, integer=True))))
Eq << apply(P)
Eq << ForAll[x[:n]:P](Contains(x[:n], P), plausible=True)
Eq << Eq[-1].simplify()
Eq << Eq[-1].this.function.subs(Eq[0])
def apply(n):
i = Symbol.i(integer=True)
p = Symbol.p(shape=(oo, ), integer=True, nonnegative=True)
P = Symbol.P(dtype=dtype.integer * n,
definition=conditionset(
p[:n],
Equality(p[:n].set_comprehension(),
Interval(0, n - 1, integer=True))))
return ForAll[p[:n]:P](Exists[i:n](Equality(p[i], n - 1)))
def prove(Eq):
n = Symbol.n(integer=True, positive=True)
m = Symbol.m(integer=True, positive=True)
x = Symbol.x(complex=True, shape=(n, ))
y = Symbol.y(complex=True, shape=(m, ))
A = Symbol.A(dtype=dtype.complex * n)
f = Function.f(nargs=(m, ), shape=(), integer=True)
g = Function.g(nargs=(n, ), shape=(m, ))
P = Symbol.P(definition=conditionset(y, Equality(f(y), 1)))
Eq << apply(ForAll[x:A](Equality(f(g(x)), 1)), P)
Eq << Eq[-1].definition
def apply(n):
i = Symbol.i(integer=True)
p = Symbol.p(shape=(oo, ), integer=True, nonnegative=True)
P = Symbol.P(dtype=dtype.integer * n,
definition=conditionset(
p[:n],
Equality(p[:n].set_comprehension(),
Interval(0, n - 1, integer=True))))
b = Symbol.b(integer=True, shape=(oo, ), nonnegative=True)
return ForAll[p[:n]:P](Exists[b[:n]](Equality(
p[:n], LAMBDA[i:n](i) @ MatProduct[i:n](Swap(n, i, b[i])))))
def apply(n, k, s2=None, B=None):
if s2 is None:
x = Symbol.x(shape=(oo, ), dtype=dtype.integer, finite=True)
s2 = Symbol.s2(
definition=UNION[x[:k + 1]:Stirling.conditionset(n + 1, k + 1, x)](
x[:k + 1].set_comprehension().set))
e = Symbol.e(**s2.element_type.dict)
if B is None:
x = s2.definition.variable.base
s0 = Symbol.s0(definition=UNION[x[:k]:Stirling.conditionset(n, k, x)](
x[:k].set_comprehension().set))
B = Symbol.B(definition=UNION[e:s0]({e | {n.set}}))
return Equality(conditionset(e, Contains({n}, e), s2), B)
def apply(given):
assert given.is_ForAll
S = given.rhs
n = S.element_type.shape[0]
ref = given.lhs
k = ref.variable
x = ref.function.base
assert len(ref.function.indices) == 1
index = ref.function.indices[0]
assert index.is_MatMul and len(index.args) == 2
assert index.args[0].is_Indexed and index.args[1].is_LAMBDA
w = index.args[0].base
i, j, _k = index.args[0].indices
assert w.definition.is_LAMBDA
(_j, zero, n_1), (_i, _zero, _n_1) = w.definition.limits
assert zero.is_zero and _zero.is_zero
assert n_1 == _n_1 == n - 1
assert _k == k and _i == i and _j == j
assert isinstance(w.definition.function, Swap)
_n, _i, _j = w.definition.function.args
assert _n == n and _i == i and _j == j
assert index.args[1].is_LAMBDA and len(index.args[1].limits) == 1
_k, *_ = index.args[1].limits[0]
assert _k == k
p = Symbol.p(shape=(oo, ), integer=True, nonnegative=True)
P = Symbol.P(dtype=dtype.integer * n,
definition=conditionset(
p[:n],
Equality(p[:n].set_comprehension(),
Interval(0, n - 1, integer=True))))
return ForAll[p[:n]:P, x:S](Contains(LAMBDA[k:n](x[p[k]]), S), given=given)
def apply(n, w=None, left=True, P=None):
i = Symbol.i(integer=True)
j = Symbol.j(integer=True)
if w is None:
w = Symbol.w(definition=LAMBDA[j:n, i:n](Swap(n, i, j)))
else:
assert len(w.shape) == 4 and all(s == n for s in w.shape)
assert w[i, j].is_Swap or w[i, j].definition.is_Swap
x = Symbol.x(shape=(oo,), integer=True, nonnegative=True)
x = x[:n]
if P is None:
P = Symbol.P(dtype=dtype.integer * n, definition=conditionset(x, Equality(x.set_comprehension(), Interval(0, n - 1, integer=True))))
if left:
return ForAll[x:P](Contains(w[i, j] @ x, P))
else:
return ForAll[x:P](Contains(x @ w[i, j], P))
def apply(given):
assert given.is_ForAll
S = given.rhs
n = S.element_type.shape[0]
k = Symbol.k(integer=True)
x = given.variable
w, i, j = given.function.lhs.args[0].args
assert w[i, j].is_Swap or w[i, j].definition.is_Swap
p = Symbol.p(shape=(oo, ), integer=True, nonnegative=True)
P = Symbol.P(dtype=dtype.integer * n,
definition=conditionset(
p[:n],
Equality(p[:n].set_comprehension(),
Interval(0, n - 1, integer=True))))
return ForAll[p[:n]:P, x:S](Contains(LAMBDA[k:n](x[p[k]]), S), given=given)
def apply(n, k, s2=None, A=None):
j = Symbol.j(domain=Interval(0, k, integer=True))
if s2 is None:
x = Symbol.x(shape=(oo, ), dtype=dtype.integer, finite=True)
s2 = Symbol.s2(
definition=UNION[x[:k + 1]:Stirling.conditionset(n + 1, k + 1, x)](
x[:k + 1].set_comprehension().set))
e = Symbol.e(**s2.element_type.dict)
if A is None:
x = s2.definition.variable.base
i = Symbol.i(integer=True)
s1_quote = Symbol("s'_1",
definition=Stirling.conditionset(n, k + 1, x))
x_quote = Symbol("x'",
definition=LAMBDA[i:k + 1](Piecewise(
({n} | x[i], Equality(i, j)), (x[i], True))))
A = Symbol.A(definition=LAMBDA[j](UNION[x[:k + 1]:s1_quote]
({x_quote.set_comprehension()})))
return Equality(conditionset(e, NotContains({n}, e), s2), UNION[j](A[j]))
def apply(m, d, w=None):
n = d.shape[0]
i = Symbol.i(integer=True)
j = Symbol.j(integer=True)
assert m >= 0
if w is None:
w = Symbol.w(definition=LAMBDA[j, i](Swap(n, i, j)))
else:
assert len(w.shape) == 4 and all(s == n for s in w.shape)
assert w[i, j].is_Swap or w[i, j].definition.is_Swap
x = Symbol.x(shape=(oo, ), integer=True, nonnegative=True)
x = x[:n]
P = Symbol.P(dtype=dtype.integer * n,
definition=conditionset(
x,
Equality(x.set_comprehension(),
Interval(0, n - 1, integer=True))))
return ForAll[x:P](Contains(x @ MatProduct[i:m](w[i, d[i]]), P))
def prove(Eq):
n = Symbol.n(domain=Interval(2, oo, integer=True))
S = Symbol.S(dtype=dtype.integer * n)
x = Symbol.x(**S.element_symbol().dtype.dict)
i = Symbol.i(integer=True)
j = Symbol.j(integer=True)
k = Symbol.k(integer=True)
e = Symbol.e(dtype=dtype.integer, given=True)
p = Symbol.p(shape=(oo, ), integer=True, nonnegative=True)
P = Symbol.P(dtype=dtype.integer * n,
definition=conditionset(
p[:n],
Equality(p[:n].set_comprehension(),
Interval(0, n - 1, integer=True))))
Eq << apply(ForAll[x:S](Equality(x.set_comprehension(), e)),
ForAll[x:S, p[:n]:P](Contains(LAMBDA[k:n](x[p[k]]), S)),
Equality(abs(e), n))
def prove(Eq):
k = Symbol.k(integer=True, positive=True)
n = Symbol.n(integer=True, positive=True)
Eq << apply(n, k)
s2 = Eq[0].lhs
s2_quote = Symbol.s_quote_2(definition=Eq[0].rhs.limits[0][1])
Eq << s2_quote.this.definition
Eq.s2_definition = Eq[0].subs(Eq[-1].reversed)
s0 = Eq[1].lhs
s0_quote = Symbol.s_quote_0(definition=Eq[1].rhs.limits[0][1])
Eq << s0_quote.this.definition
Eq << Eq[1].subs(Eq[-1].reversed)
s0_definition = Eq[-1]
e = Symbol.e(dtype=dtype.integer.set)
s0_ = image_set(Union(e, {n.set}), e, s0)
plausible0 = Subset(s0_, s2, plausible=True)
Eq << plausible0
Eq << Eq[-1].definition
Eq << Eq[-1].this.limits[0][1].subs(s0_definition)
Eq << Eq[-1].subs(Eq.s2_definition)
s0_plausible = Eq[-1]
Eq.s2_quote_definition = s2_quote.assertion()
Eq << s0_quote.assertion()
Eq << Eq[-1].split()
x_abs_positive = Eq[-3]
x_abs_sum = Eq[-2]
x_union_s0 = Eq[-1]
i = Eq[-1].lhs.limits[0][0]
x = Eq[-1].variable.base
Eq << Equality.define(x[k], {n})
x_k_definition = Eq[-1]
Eq << Eq[-1].union(Eq[-2])
x_union = Eq[-1]
Eq << x_k_definition.set
Eq << Eq[-1].union(x[:k].set_comprehension())
Eq << s0_plausible.subs(Eq[-1].reversed)
Eq << Eq[-1].definition.definition
Eq << x_k_definition.abs()
Eq << Eq[-1].subs(StrictGreaterThan(1, 0, plausible=True))
Eq << x_abs_sum + Eq[-2]
Eq << (x_abs_positive & Eq[-2])
Eq << (x_union & Eq[-1] & Eq[-2])
j = Symbol.j(domain=Interval(0, k, integer=True))
B = Eq[2].lhs
Eq << plausible0.subs(Eq[2].reversed)
Eq << s2.this.bisect(conditionset(e, Contains({n}, e), s2))
Eq.subset_B = Subset(Eq[-1].rhs.args[0], Eq[-2].lhs,
plausible=True) # unproven
Eq.supset_B = Supset(Eq[-1].rhs.args[0], Eq[-2].lhs,
plausible=True) # unproven
Eq << Eq.supset_B.subs(Eq[2])
Eq << Eq[-1].definition.definition
Eq << Eq.subset_B.subs(Eq[2])
Eq << Eq[-1].definition.definition
Eq.subset_B_definition = Eq[-1] - {n.set}
num_plausibles = len(Eq.plausibles_dict)
Eq.plausible_notcontains = ForAll(NotContains({n}, e), (e, s0),
plausible=True)
Eq << Eq.plausible_notcontains.this.limits[0][1].subs(s0_definition)
Eq << ~Eq[-1]
Eq << Eq[-1].definition
Eq << x_union_s0.union(Eq[-1].reversed).this().function.lhs.simplify()
Eq << Eq[-1].subs(x_union_s0)
assert num_plausibles == len(Eq.plausibles_dict)
Eq << Eq.plausible_notcontains.apply(
sets.notcontains.imply.equality.emptyset)
Eq.s0_complement_n = Eq[-1].apply(
sets.equality.imply.equality.given.emptyset.complement)
Eq << Eq.subset_B_definition.subs(Eq.s0_complement_n)
s2_n = Symbol('s_{2, n}', definition=Eq[-1].limits[0][1])
Eq.s2_n_definition = s2_n.this.definition
Eq << s2_n.assertion()
Eq << Eq[-1].subs(Eq.s2_definition).split()
Eq.s2_n_assertion = Eq[-2].definition
Eq << Eq[-1].subs(Eq.s2_n_assertion)
Eq << Eq[-1].definition
Eq.x_j_definition = Eq[-1].limits_subs(Eq[-1].variable, j).reversed
Eq.x_abs_positive_s2, Eq.x_abs_sum_s2, Eq.x_union_s2 = Eq.s2_quote_definition.split(
)
Eq << Eq.x_union_s2 - Eq.x_j_definition
Eq << Eq[-1].this.function.lhs.args[0].bisect({j})
x_tilde = Symbol(r"\tilde{x}",
shape=(k, ),
dtype=dtype.integer,
definition=LAMBDA[i:k](Piecewise((x[i], i < j),
(x[i + 1], True))))
Eq.x_tilde_definition = x_tilde.equality_defined()
Eq << Eq.x_tilde_definition.union_comprehension((i, 0, k - 1))
Eq << Eq[-1].this.rhs.args[1].limits_subs(i, i - 1)
Eq.x_tilde_union = Eq[-1].subs(Eq[-3])
Eq.x_tilde_abs = Eq.x_tilde_definition.abs()
Eq << Eq.x_tilde_abs.sum((i, 0, k - 1))
Eq << Eq[-1].this.rhs.args[0].limits_subs(i, i - 1)
Eq.x_tilde_abs_sum = Eq[-1].subs(Eq.x_abs_sum_s2, Eq.x_j_definition.abs())
Eq << Eq.x_tilde_abs.as_Or()
Eq << Eq[-1].forall((i, i < j))
Eq << Eq[-2].forall((i, i >= j))
Eq << Eq[-2].subs(Eq.x_abs_positive_s2)
Eq << Eq[-2].subs(Eq.x_abs_positive_s2.limits_subs(i, i + 1))
Eq << (Eq[-1] & Eq[-2])
Eq << (Eq[-1] & Eq.x_tilde_abs_sum & Eq.x_tilde_union)
Eq << Eq[-1].func(
Contains(x_tilde, s0_quote), *Eq[-1].limits, plausible=True)
Eq << Eq[-1].definition
Eq << Eq[-1].this.function.args[0].simplify()
Eq.x_tilde_set_in_s0 = Eq[-3].func(Contains(
UNION.construct_finite_set(x_tilde), s0),
*Eq[-3].limits,
plausible=True)
Eq << Eq.x_tilde_set_in_s0.subs(s0_definition)
Eq << Eq[-1].definition
Eq << Eq.x_tilde_definition.set.union_comprehension((i, 0, k - 1))
Eq << Eq[-1].subs(Eq.x_j_definition)
Eq << Eq[-1].subs(Eq.s2_n_assertion.reversed)
Eq << Eq.x_tilde_set_in_s0.subs(Eq[-1])
Eq << Eq[-1].this.limits[0].subs(Eq.s2_n_definition)
Eq.subset_B_plausible = Eq.subset_B_definition.union({n.set})
Eq << Eq.subset_B_plausible.limits_assertion()
Eq << Eq[-1].definition.split()[1]
Eq << Eq[-1].apply(sets.contains.imply.equality.union)
Eq << Eq.subset_B_plausible.subs(Eq[-1])
Eq << Eq.supset_B.subs(Eq.subset_B)
