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)