def prove(Eq):
A = Symbol.A(dtype=dtype.integer)
B = Symbol.B(dtype=dtype.integer)
Eq << apply(Supset(A, B))
Eq << Eq[0].reversed
Eq << sets.subset.imply.less_than.apply(Eq[-1])
Eq << Eq[-1].reversed
def prove(Eq):
A = Symbol.A(dtype=dtype.integer)
B = Symbol.B(dtype=dtype.integer)
subset = Subset(A, B)
Eq << apply(subset)
Eq << Eq[0].union(B)
Eq << Supset(*Eq[-1].args, plausible=True)
Eq << Eq[-1].subs(Eq[-2])
def prove(Eq):
n = Symbol.n(integer=True, positive=True)
p = Symbol.p(integer=True, shape=(n, ))
x = Symbol.x(integer=True, shape=(n, ))
Eq << apply(
Equality(p.set_comprehension(), Interval(0, n - 1, integer=True)), x)
A = Symbol.A(definition=Eq[1].lhs)
B = Symbol.B(definition=Eq[1].rhs)
Eq.A_definition = A.this.definition
i = Eq[1].lhs.variable
_i = Symbol.i(domain=Interval(0, n - 1, integer=True))
Eq.A_definition = Eq.A_definition.this.rhs.limits_subs(i, _i)
j = Eq[1].rhs.variable
_j = Symbol.j(domain=Interval(0, n - 1, integer=True))
Eq.B_definition = B.this.definition
Eq.B_definition = Eq.B_definition.this.rhs.limits_subs(
Eq.B_definition.rhs.variable, _j)
Eq.subset = Subset(Eq.A_definition.rhs,
Eq.B_definition.rhs,
plausible=True)
Eq << Eq.subset.simplify()
Eq << Eq[-1].definition
Eq << Eq[-1].subs(Eq[-1].variable, p[_i])
Eq.supset = Supset(Eq.subset.lhs, Eq.subset.rhs, plausible=True)
Eq << Eq.supset.simplify()
Eq.definition = Eq[-1].definition
Eq << discrete.combinatorics.permutation.index.equality.apply(Eq[0], _j)
index_j = Eq[-1].lhs.indices[0]
Eq << Eq.definition.subs(Eq[-1].reversed)
Eq << Eq[-1].subs(Eq[-1].variable, index_j)
Eq <<= Eq.subset & Eq.supset
Eq << Eq[-1].this.lhs.limits_subs(_i, i)
Eq << Eq[-1].this.rhs.limits_subs(_j, j)
def prove(Eq):
A = Symbol.A(dtype=dtype.integer)
B = Symbol.B(dtype=dtype.integer)
subset = Subset(A, B)
Eq << apply(subset)
Eq << Eq[0].intersect(A)
Eq << Supset(*Eq[-1].args, plausible=True)
Eq <<= Eq[-1] & Eq[-2]
Eq << Eq[-1].reversed
def prove(Eq):
A = Symbol.A(dtype=dtype.integer)
B = Symbol.B(dtype=dtype.integer)
C = Symbol.C(dtype=dtype.integer)
subset = Subset(A, B, evaluate=False)
equality = Equality(B & C, S.EmptySet, evaluate=False)
Eq << apply(equality, subset)
Eq << subset.intersect(C)
Eq << Eq[-1].subs(equality)
Eq << Supset(*Eq[-1].args, plausible=True)
Eq << Eq[-1].subs(Eq[-2])
def prove(Eq):
n = Symbol.n(integer=True, positive=True)
i = Symbol.i(integer=True)
x = Symbol.x(shape=(oo, ), dtype=dtype.complex * n)
A = Symbol.A(dtype=dtype.complex * n)
m = Symbol.m(integer=True, positive=True)
Eq << apply(Supset(A, x[i]), (i, 0, m - 1))
Eq << Eq[-1].subs(m, 1)
Eq << Eq[0].subs(i, 0)
Eq << Eq[1].subs(m, m + 1)
Eq << Eq[0].subs(i, m)
Eq <<= Eq[-1] & Eq[1]
def prove(Eq):
A = Symbol.A(dtype=dtype.integer)
B = Symbol.B(dtype=dtype.integer)
subset = Subset(A, B, evaluate=False)
Eq << apply(subset)
Eq << sets.imply.equality.inclusion_exclusion_principle.apply(B - A, B & A)
Eq << Eq[-1].subs(Eq[-2])
Eq << subset.intersect(A)
Eq << Supset(*Eq[-1].args, plausible=True)
Eq << Eq[-1].subs(Eq[-2])
Eq << Eq[-1].abs()
def prove(Eq):
k = Symbol.k(integer=True, positive=True)
n = Symbol.n(integer=True, positive=True)
Eq << apply(n, k)
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)
s1_quote = Eq[2].lhs
Eq << s1_quote.assertion()
i = Eq[1].lhs.indices[0]
x_slice = Eq[-1].limits[0][0]
x = x_slice.base
Eq.x_abs_positive_s1, Eq.x_abs_sum_s1, Eq.x_union_s1 = Eq[-1].split()
j = Symbol.j(domain=Interval(0, k, integer=True))
x_quote = Eq[1].lhs.base
Eq.x_quote_set_in_s2 = Subset(image_set(UNION[i:0:k](x_quote[i].set),
x_slice, s1_quote),
Eq[0].lhs,
plausible=True)
Eq << Eq.x_quote_set_in_s2.definition
Eq << Eq[-1].subs(Eq.s2_definition)
Eq << Eq[-1].definition.definition
Eq << Eq[-1].this.function.args[0].simplify()
Eq << Eq[1].union_comprehension((i, 0, k))
x_quote_union = Eq[-1].subs(Eq.x_union_s1)
Eq << x_quote_union
Eq << Eq[1].abs()
x_quote_abs = Eq[-1]
Eq << Eq[-1].sum((i, 0, k))
Eq << sets.imply.less_than.union.apply(*Eq[-1].rhs.args[1].arg.args)
Eq << Eq[-2].subs(Eq[-1])
Eq << Eq[-1].subs(Eq.x_abs_sum_s1)
Eq << x_quote_union.abs()
x_quote_union_abs = Eq[-1]
u = Eq[-1].lhs.arg
Eq << sets.imply.less_than.union_comprehension.apply(u.function, *u.limits)
Eq << Eq[-2].subs(Eq[-1])
Eq << Eq[-4].subs(Eq[-1])
SqueezeTheorem = Eq[-1]
Eq << x_quote_abs.as_Or()
Eq << Eq[-1].subs(i, j)
Eq << Eq[-2].forall((i, Unequality(i, j)))
Eq << sets.imply.greater_than.apply(*Eq[-2].rhs.arg.args[::-1])
Eq << Eq[-1].subs(Eq.x_abs_positive_s1.limits_subs(i, j))
Eq << Eq[-4].subs(Eq[-1])
Eq << Eq[-4].subs(Eq.x_abs_positive_s1)
Eq << (Eq[-1] & Eq[-2])
Eq << (x_quote_union & SqueezeTheorem & Eq[-1])
Eq.x_quote_definition = Eq[1].reference((i, 0, k))
Eq.subset_A = Subset(Eq[4].lhs, Eq[4].rhs, plausible=True)
Eq.supset_A = Supset(Eq[4].lhs, Eq[3].lhs, plausible=True)
Eq << Eq.supset_A.subs(Eq[3])
Eq << Eq[-1].definition.definition
Eq << Eq[-1].split()
notContains = Eq[-1]
Eq << ~Eq[-1]
Eq << Eq[-1].definition
Eq << Eq.x_quote_definition[j]
Eq << Eq[-1].intersect(Eq[-2].reversed)
Eq << sets.imply.equality.inclusion_exclusion_principle.apply(
*Eq[-1].lhs.args)
Eq << Eq[-1].subs(Eq[-2])
Eq.set_size_inequality = Eq[-1].subs(
StrictLessThan(Eq[-1].function.rhs,
Eq[-1].function.rhs + 1,
plausible=True))
Eq << x_quote_union.this.function.lhs.bisect({i, j})
Eq << sets.imply.less_than.union.apply(*Eq[-1].lhs.args)
Eq << sets.imply.less_than.union_comprehension.apply(
*Eq[-2].lhs.args[0].args)
Eq << Eq[-2].subs(Eq[-1]) + Eq.set_size_inequality
Eq << Eq[-1].this().function.rhs.args[-1].simplify()
Eq << Eq[-1].this().function.rhs.args[0].arg.simplify()
Eq << Eq[-1].subs(x_quote_union_abs)
Eq << Eq[-1].subs(SqueezeTheorem)
Eq << Eq.subset_A.subs(Eq[3])
Eq << Eq[-1].definition.definition
s2_hat_n = Symbol("\hat{s}_{2, n}", definition=Eq[-1].limits[0][1])
Eq << s2_hat_n.this.definition
Eq.s2_hat_n_assertion = Eq[-2].this.limits[0].subs(Eq[-1].reversed)
Eq << Eq[-1].this.rhs.as_image_set()
s2_quote_n = Symbol("s'_{2, n}", definition=Eq[-1].rhs.limits[0][1])
assert s2_quote_n in s2_quote
assert Supset(s2_quote, s2_quote_n)
Eq << s2_quote_n.this.definition
Eq << Eq[-2].subs(Eq[-1].reversed)
Eq.s2_hat_n_hypothesis = Eq.s2_hat_n_assertion.this.limits[0].subs(Eq[-1])
Eq << s2_quote_n.assertion()
Eq.n_not_in_x, Eq.x_abs_positive_s2_n, Eq.x_abs_sum_s2_n, Eq.x_union_s2_n = Eq[
-1].split()
Eq << Eq.n_not_in_x.definition
Eq.x_j_inequality = Eq[-1].limits_subs(i, j)
Eq << Eq.x_union_s2_n.func(Contains(n, Eq.x_union_s2_n.lhs),
*Eq.x_union_s2_n.limits,
plausible=True)
Eq << Eq[-1].subs(Eq.x_union_s2_n)
Eq << Eq[-1].definition
x_hat = Symbol(r"\hat{x}",
shape=(oo, ),
dtype=dtype.integer,
definition=LAMBDA[i](Piecewise(
(x_slice[i] - {n}, Equality(i, j)),
(x_slice[i], True))))
Eq.x_hat_definition = x_hat.equality_defined()
Eq << Eq[-1].this.function.limits_subs(i, j)
Eq.x_j_subset = Eq[-1].apply(sets.contains.imply.subset, simplify=False)
Eq << Eq.x_j_subset.apply(sets.inequality.subset.imply.inequality,
Eq.x_j_inequality,
simplify=False)
Eq.x_j_abs_positive = Eq[-1].apply(
sets.inequality.imply.strict_greater_than)
Eq.x_hat_abs = Eq.x_hat_definition.abs()
Eq << Eq.x_hat_abs.as_Or()
Eq << Eq[-1].subs(i, j)
Eq << Eq[-2].forall((i, Unequality(i, j)))
Eq << Eq[-1].subs(Eq.x_abs_positive_s2_n) # -1
Eq << Eq[-3].subs(Eq.x_j_abs_positive)
Eq.x_hat_abs_positive = Eq[-1] & Eq[-2]
Eq.x_hat_union = Eq.x_hat_definition.union_comprehension((i, 0, k))
Eq.x_union_complement = Eq.x_union_s2_n - {n}
Eq << Eq.x_union_s2_n.abs().subs(Eq.x_abs_sum_s2_n.reversed).apply(
sets.equality.imply.forall_equality.nonoverlapping)
Eq << Eq[-1].limits_subs(Eq[-1].variables[1], j).limits_subs(
Eq[-1].variable, i)
Eq.x_complement_n = Eq[-1].apply(sets.equality.subset.imply.equality,
Eq.x_j_subset)
Eq << Eq.x_complement_n.this.function.function.union_comprehension(
*Eq.x_complement_n.function.function.limits)
Eq << Eq.x_hat_union.subs(Eq[-1].reversed)
Eq.x_hat_union = Eq[-1].subs(Eq.x_union_complement)
Eq << Eq.x_hat_abs.sum((i, 0, k)).subs(Eq.x_abs_sum_s2_n)
Eq << Eq.x_j_subset.apply(sets.subset.imply.equality.complement)
Eq << Eq[-2].subs(Eq[-1])
Eq << (Eq[-1] & Eq.x_hat_abs_positive & Eq.x_hat_union)
function = Contains(x_hat[:k + 1], s1_quote)
function = Eq[-1].function.func(function, *Eq[-1].function.limits)
Eq.x_hat_in_s1 = Eq[-1].func(function, *Eq[-1].limits, plausible=True)
Eq << Eq.x_hat_in_s1.definition
Eq << Eq.x_hat_definition.as_Or()
Eq << Eq[-1].subs(i, j)
Eq << Eq[-2].forall((i, Unequality(i, j)))
Eq <<= Eq[-1] & Eq.x_complement_n.reversed
Eq << (Eq[-1] & Eq[-3])
Eq << Eq[-1].this.function.function.reference(
*Eq[-1].function.function.limits)
Eq << Eq.x_hat_in_s1.subs(Eq[-1])
Eq << Eq.s2_hat_n_hypothesis.strip().strip()
Eq << Eq[-1].subs(Eq.x_quote_definition)
Eq.equation = Eq[-1] - {n}
Eq << Eq.x_union_s1.intersect({n})
Eq.nonoverlapping_s1_quote = Eq[-1].apply(
sets.equality.imply.equality.given.emptyset.intersect)
Eq.xi_complement_n = Eq.nonoverlapping_s1_quote.apply(
sets.equality.imply.equality.given.emptyset.complement, reverse=True)
Eq << Eq.equation.subs(Eq.xi_complement_n)
a = Eq[-1].variable
b = Symbol.b(**a.dtype.dict)
Eq << Eq[-1].limits_subs(a, b)
Eq << Eq[-1].this.function.subs(x[:k + 1], a)
Eq << Eq[-1].limits_subs(b, x[:k + 1])
Eq << Eq[-1].this.function.function.reference((i, 0, k))
Eq.supset_A = sets.supset.imply.supset.apply(Eq.supset_A, (j, ),
simplify=False)
Eq << Eq.supset_A.subs(Eq.subset_A)
def apply(given):
assert given.is_Equality
A, B = given.args
assert A.is_set and B.is_set
return Supset(A, B, given=given)
def apply(given, *limits):
assert given.is_Supset
A, fx = given.args
return Supset(A, UNION(fx, *limits).simplify(), given=given)
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)