def prove(Eq):
e = Symbol.e(integer=True)
A = Symbol.A(dtype=dtype.integer)
B = Symbol.B(dtype=dtype.integer)
Eq << apply(NotContains(e, A), NotContains(e, B))
Eq << Eq[-1].split()
def apply(given):
assert given.is_Equality
AB, emptyset = given.args
if emptyset != S.EmptySet:
tmp = emptyset
emptyset = AB
AB = tmp
assert AB.is_Intersection
A, B = AB.args
if A.is_FiniteSet:
if len(A) != 1:
swap = True
else:
swap = False
else:
swap = True
if swap:
A, B = B, A
assert A.is_FiniteSet and len(A) == 1
a, *_ = A.args
return NotContains(a, B, given=given)
def apply(given, limit):
assert given.is_NotContains
k, a, b = limit
e, A = given.args
assert Interval(a, b, integer=True) in A.domain_defined(k)
return NotContains(e, UNION[k:a:b](A), given=given)
def prove(Eq):
S = Symbol.S(dtype=dtype.integer)
e = Symbol.e(integer=True)
Eq << apply(NotContains(e, S))
Eq << sets.notcontains.imply.equality.emptyset.apply(Eq[0])
Eq << sets.equality.imply.equality.given.emptyset.complement.apply(Eq[-1])
def apply(*given):
notcontains1, notcontains2 = given
assert notcontains1.is_NotContains
assert notcontains2.is_NotContains
e, A = notcontains1.args
_e, B = notcontains2.args
assert e == _e
return NotContains(e, A | B, given=given)
def prove(Eq):
s = Symbol.s(dtype=dtype.integer, given=True)
e = Symbol.e(integer=True, given=True)
Eq << apply(NotContains(e, s))
Eq << ~Eq[-1]
Eq << sets.inequality.imply.exists.overlapping.apply(Eq[-1])
Eq <<= Eq[-1] & Eq[0]
def prove(Eq):
n = Symbol.n(domain=[1, oo], integer=True)
x = Symbol.x(integer=True)
k = Symbol.k(integer=True)
A = Symbol.A(shape=(oo, ), dtype=dtype.integer)
Eq << apply(NotContains(x, A[k]), (k, 0, n - 1))
Eq << Eq[-1].subs(n, 1)
Eq << Eq[0].subs(k, 0)
Eq << Eq[1].subs(n, n + 1)
Eq << Eq[0].subs(k, n)
Eq <<= Eq[-1] & Eq[1]
def subs(self, *args, **kwargs):
if all(isinstance(arg, Boolean) for arg in args):
return ConditionalBoolean.subs(self, *args, **kwargs)
old, new = args
if old.is_Slice:
return self._subs_slice(old, new)
new = sympify(new)
if old in self.variables:
wrt, *ab = self.limits[self.variables.index(old)]
if len(ab) == 1:
domain = ab[0]
else:
a, b = ab
if b.is_set:
domain = b & old.domain_conditioned(a)
else:
from sympy import Range
domain = (Range if wrt.is_integer else Interval)(a, b)
eqs = []
if not domain.is_set:
domain = old.domain_conditioned(domain)
from sympy.sets.contains import NotContains
limit_cond = NotContains(new, domain).simplify()
eqs.append(limit_cond)
if self.function.is_Or:
for equation in self.function.args:
eqs.append(equation._subs(old, new))
else:
eqs.append(self.function._subs(old, new))
limits = self.limits_delete(old)
if limits:
for i, (x, *ab) in enumerate(limits):
if ab:
limits[i] = (x, *(expr._subs(old, new) for expr in ab))
return self.func(Or(*eqs), *limits, given=self)
else:
return Or(*eqs, given=self).simplify()
return ConditionalBoolean.subs(self, *args, **kwargs)
def prove(Eq):
n = Symbol.n(integer=True, positive=True, given=True)
p = Symbol.p(shape=(oo, ), integer=True, nonnegative=True, given=True)
Eq << apply(
Equality(p[:n + 1].set_comprehension(), Interval(0, n, integer=True)),
Equality(p[n], n))
Eq << Eq[0].this.lhs.bisect(Slice[-1:])
Eq << Eq[-1].subs(Eq[1])
Eq << Eq[-1] - n.set
Eq << Eq[-1].subs(Eq[2].reversed)
Eq.plausible = NotContains(n, Eq[-1].rhs, plausible=True)
Eq << ~Eq.plausible
Eq << Eq[-1].definition
i = Eq[-1].variable
_i = i.copy(domain=[0, n - 1])
Eq << Eq[-1].limits_subs(i, _i)
Eq << Eq[0].lhs.this.bisect({_i, n})
Eq.paradox = Eq[-1].subs(Eq[-2].reversed).subs(Eq[1])
Eq << sets.imply.less_than.union.apply(*Eq.paradox.function.rhs.args)
Eq << sets.imply.less_than.union_comprehension.apply(
*Eq.paradox.function.rhs.args[1].args)
Eq << Eq[-2] + Eq[-1]
Eq << Eq.paradox.abs().subs(Eq[0])
Eq << Eq[-2].subs(Eq[-1].reversed)
Eq << sets.notcontains.imply.equality.complement.apply(Eq.plausible)
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(given):
assert given.is_Unequality
x, y = given.args
return NotContains(x, y.set, given=given)
def simplify(self, **kwargs):
from sympy import S
from sympy.sets.contains import Contains, NotContains
if self.function.is_Equal:
limits_dict = self.limits_dict
x = None
if self.function.lhs in limits_dict:
x = self.function.lhs
y = self.function.rhs
elif self.function.rhs in limits_dict:
x = self.function.rhs
y = self.function.lhs
if x is not None and not y.has(x):
domain = limits_dict[x]
if isinstance(domain, list):
if len(self.limits) == 1:
if all(not var.is_given for var in y.free_symbols):
return S.BooleanTrue
elif domain.is_set:
t = self.variables.index(x)
if not any(limit._has(x) for limit in self.limits[:t]):
function = Contains(y, domain)
if function:
return function
limits = self.limits_delete(x)
if limits:
return self.func(function, *limits)
return function
from sympy import Unequal, Equal
if self.function.is_Contains:
limits_dict = self.limits_dict
x = None
if self.function.lhs in limits_dict:
x = self.function.lhs
S = self.function.rhs
if x is not None:
domain = limits_dict[x]
if isinstance(domain, list):
return self
# function = Unequal(S, x.emptySet)
elif domain.is_set:
if domain.is_FiniteSet:
function = Contains(domain.arg, S)
else:
function = Unequal(S & domain, x.emptySet)
else:
function = None
if function is not None:
limits = self.limits_delete((x, ))
if limits:
return self.func(function, *limits).simplify()
else:
if function.is_BooleanAtom:
return function
return function
elif self.function.is_NotContains:
limits_dict = self.limits_dict
x = None
if self.function.lhs in limits_dict:
x = self.function.lhs
S = self.function.rhs
if x is not None:
domain = limits_dict[x]
if isinstance(domain, list):
function = Equal(S, x.emptySet)
elif domain.is_set:
if domain.is_FiniteSet:
function = NotContains(domain.arg, S)
else:
function = Unequal(domain // S, x.emptySet)
else:
function = None
if function is not None:
limits = self.limits_delete((x, ))
if limits:
return self.func(function, *limits).simplify()
else:
if function.is_BooleanAtom:
return function
return function
if self.function.is_And:
limits_dict = self.limits_dict
for i, eq in enumerate(self.function.args):
if eq.is_Contains and eq.lhs in limits_dict:
domain = limits_dict[eq.lhs]
if isinstance(domain, list):
eqs = [*self.function.args]
del eqs[i]
if not eq.rhs.has(*self.variables[:i]):
return self.func(
And(*eqs),
*self.limits_update(eq.lhs,
eq.rhs)).simplify()
elif domain == eq.rhs:
eqs = [*self.function.args]
del eqs[i]
return self.func(And(*eqs), *self.limits)
if eq.is_Equal:
if eq.lhs in limits_dict:
old, new = eq.args
elif eq.rhs in limits_dict:
new, old = eq.args
else:
continue
continue
if self.function.is_Or:
limits_dict = self.limits_dict
for i, eq in enumerate(self.function.args):
if eq.is_NotContains and eq.lhs in limits_dict:
domain = limits_dict[eq.lhs]
if not isinstance(domain, list) and domain in eq.rhs:
eqs = [*self.function.args]
del eqs[i]
return self.func(And(*eqs), *self.limits)
if eq.is_Unequal:
continue
if eq.lhs in limits_dict:
old, new = eq.args
elif eq.rhs in limits_dict:
new, old = eq.args
else:
continue
limits = self.limits_delete(old)
if any(limit._has(old) for limit in limits):
continue
eqs = [*self.function.args]
del eqs[i]
eqs = [eq._subs(old, new) for eq in eqs]
domain = limits_dict[old]
if isinstance(domain, list):
limit = (old, )
else:
limit = (old, domain)
eq = self.func(eq, limit).simplify()
eqs.append(eq)
return self.func(And(*eqs), *limits).simplify()
if self.function.is_Equal:
limits_dict = self.limits_dict
x = None
if self.function.lhs in limits_dict:
x = self.function.lhs
y = self.function.rhs
elif self.function.rhs in limits_dict:
x = self.function.rhs
y = self.function.lhs
return ConditionalBoolean.simplify(self, **kwargs)
def prove(Eq):
k = Symbol.k(integer=True, positive=True)
n = Symbol.n(integer=True, positive=True)
Eq << apply(n, k)
s0 = Eq[0].lhs
s0_quote = Symbol.s_quote_0(definition=s0.definition.limits[0][1])
Eq << s0_quote.this.definition
Eq.s0_definition = Eq[0].subs(Eq[-1].reversed)
e = Symbol.e(dtype=dtype.integer.set)
Eq << s0_quote.assertion()
*_, Eq.x_union_s0 = Eq[-1].split()
i = Symbol.i(integer=True)
x = Eq[0].rhs.variable.base
j = Symbol.j(domain=[0, k], integer=True)
B = Eq[1].lhs
Eq.plausible_notcontains = ForAll(NotContains({n}, e), (e, s0),
plausible=True)
Eq << Eq.plausible_notcontains.this.limits[0][1].subs(Eq.s0_definition)
Eq << ~Eq[-1]
Eq << Eq[-1].definition
Eq << Eq.x_union_s0.union(Eq[-1].reversed).this().function.lhs.simplify()
Eq << Eq[-1].subs(Eq.x_union_s0)
Eq << Eq.plausible_notcontains.apply(
sets.notcontains.imply.equality.emptyset)
Eq.forall_s0_equality = Eq[-1].apply(
sets.equality.imply.equality.given.emptyset.complement)
x_hat = Symbol(r"\hat{x}",
shape=(oo, ),
dtype=dtype.integer,
definition=LAMBDA[i](Piecewise((x[i] - {n}, Equality(i, j)),
(x[i], True))))
Eq.x_hat_definition = x_hat.equality_defined()
Eq << Eq.x_hat_definition.as_Or()
Eq << Eq[-1].forall((i, Unequality(i, j)))
a = Eq[-1].variable
b = Symbol.b(**a.dtype.dict)
Eq.B_assertion = B.assertion()
Eq << Eq.B_assertion - {n.set}
Eq.forall_B_contains = Eq[-1].subs(Eq.forall_s0_equality).limits_subs(
Eq[-1].variable, Eq[-1].function.variable)
Eq.forall_s0_contains = B.assertion(reverse=True)
Eq << Eq.B_assertion.intersect({n.set}).limits_subs(
Eq.B_assertion.variable, Eq.B_assertion.function.variable)
Eq.forall_B_equality = Eq[-1].union(Eq[-1].variable)
Eq << sets.forall_contains.forall_contains.forall_equality.forall_equality.imply.equality.apply(
Eq.forall_s0_contains, Eq.forall_B_contains, Eq.forall_s0_equality,
Eq.forall_B_equality)
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)