def image_set_definition(self, reverse=False):
image_set = self.image_set()
if image_set is None:
return
expr, variables, base_set = image_set
from sympy.tensor.indexed import Slice
from sympy.core.relational import Equality
from sympy.concrete.expr_with_limits import ForAll, Exists
if isinstance(base_set, Symbol):
if reverse:
return ForAll(Contains(expr, self), (variables, base_set))
element_symbol = self.element_symbol()
assert expr.dtype == element_symbol.dtype
condition = Equality(expr, element_symbol)
return ForAll(Exists(condition, (variables, base_set)), (element_symbol, self))
else:
if not isinstance(base_set, ConditionSet):
return
variable = base_set.variable
if isinstance(variable, Symbol):
...
elif isinstance(variable, Slice):
condition = base_set.condition
element_symbol = self.element_symbol()
assert expr.dtype == element_symbol.dtype
exists = Exists(condition.func(*condition.args), (variables, Equality(expr, element_symbol)))
return ForAll(exists, (element_symbol, self))
def apply(given):
assert given.is_ForAll
eq = given.function
assert eq.is_Equality
limits = given.limits
* limits, (_, j_domain) = limits
assert j_domain.is_Complement
n_interval, i = j_domain.args
n = n_interval.stop
i, *_ = i.args
intersection, emptyset = eq.args
assert emptyset.is_EmptySet
xi, xj = intersection.args
if not xi.has(i):
xi = xj
assert xj.has(i)
eq = Equality(abs(UNION[i:0:n - 1](xi)), Sum[i:0:n - 1](abs(xi)))
if limits:
return ForAll(eq, *limits, given=given)
else:
eq.given = given
return eq
def apply(given, excludes=None):
assert given.is_Equality
x_union_abs, x_abs_sum = given.args
if not x_union_abs.is_Abs:
tmp = x_union_abs
x_union_abs = x_abs_sum
x_abs_sum = tmp
assert x_union_abs.is_Abs
x_union = x_union_abs.arg
assert x_union.is_UNION
if x_abs_sum.is_Sum:
assert x_abs_sum.function.is_Abs
assert x_abs_sum.function.arg == x_union.function
else:
assert x_abs_sum == summation(abs(x_union.function), *x_union.limits)
limits_dict = x_union.limits_dict
i, *_ = limits_dict.keys()
xi = x_union.function
kwargs = i._assumptions.copy()
if 'domain' in kwargs:
del kwargs['domain']
j = xi.generate_free_symbol(excludes=excludes, **kwargs)
xj = xi.subs(i, j)
i_domain = limits_dict[i] or i.domain
limits = [(j, i_domain - {i})] + [*x_union.limits]
return ForAll(Equality(xi & xj, S.EmptySet).simplify(),
*limits,
given=given)
def apply(given):
assert given.is_ForAll and len(given.limits) == 2
j, a, n_munis_1 = given.limits[0]
assert a == 1
x, S = given.limits[1]
contains = given.function
assert contains.is_Contains
ref, _S = contains.args
assert S == _S and ref.is_LAMBDA and S.is_set
dtype = S.element_type
assert len(ref.limits) == 1
i, a, _n_munis_1 = ref.limits[0]
assert _n_munis_1 == n_munis_1 and a == 0
piecewise = ref.function
assert piecewise.is_Piecewise and len(piecewise.args) == 3
x0, condition0 = piecewise.args[0]
assert condition0.is_Equality and {*condition0.args} == {i, j}
xj, conditionj = piecewise.args[1]
assert conditionj.is_Equality and {*conditionj.args} == {i, 0}
xi, conditioni = piecewise.args[2]
assert conditioni
n = n_munis_1 + 1
assert x[j] == xj and x[i] == xi and x[0] == x0 and dtype == x.dtype
w = Symbol.w(definition=LAMBDA[j:n, i:n](Swap(n, i, j)))
return ForAll(Contains(w[i, j] @ x, S), (x, S), given=given)
def definition(self):
e, S = self.args
from sympy.concrete.expr_with_limits import ForAll
image_set = S.image_set()
if image_set is not None:
expr, variables, base_set = image_set
from sympy import Wild
variables_ = Wild(variables.name, **variables.dtype.dict)
e = e.subs_limits_with_epitome(expr)
dic = e.match(expr.subs(variables, variables_))
if dic:
variables_ = dic[variables_]
if variables.dtype != variables_.dtype:
assert len(variables.shape) == 1
variables_ = variables_[:variables.shape[-1]]
return self.func(variables_, base_set, equivalent=self)
if e.has(variables):
_variables = base_set.element_symbol(e.free_symbols)
assert _variables.dtype == variables.dtype
expr = expr._subs(variables, _variables)
variables = _variables
assert not e.has(variables)
return ForAll(Unequality(e, expr, evaluate=False),
(variables, base_set),
equivalent=self)
condition_set = S.condition_set()
if condition_set:
return Or(
~condition_set.condition._subs(condition_set.variable, e),
~self.func(e, condition_set.base_set),
equivalent=self)
if S.is_UNION:
contains = self.func(self.lhs, S.function).simplify()
contains.equivalent = None
return ForAll(contains, *S.limits, equivalent=self).simplify()
return self
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 apply(n, w=None):
i = Symbol.i(domain=Interval(0, n - 1, integer=True))
j = Symbol.j(domain=Interval(0, n - 1, integer=True))
assert n >= 2
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)
return ForAll(Equality(w[0, i] @ w[0, j] @ w[0, i], w[i, j]), (j, Interval(1, n - 1, integer=True) - i.set))
def apply(n, w=None):
domain = Interval(0, n - 1, integer=True)
t = Symbol.t(domain=domain)
i = Symbol.i(domain=domain)
j = Symbol.j(domain=domain)
assert n >= 2
if w is None:
w = Symbol.w(definition=LAMBDA[j, i](Swap(n, i, j)))
return ForAll(Equality(w[t, i] @ w[t, j] @ w[t, i], w[i, j]),
(j, domain - {i, t}))
def apply(given):
assert given.is_Equality
x_union, emptyset = given.args
if emptyset != S.EmptySet:
tmp = emptyset
emptyset = x_union
x_union = tmp
assert emptyset == S.EmptySet
assert x_union.is_UNION
return ForAll(Equality(x_union.function, S.EmptySet), *x_union.limits, given=given)
def simplify(self, deep=False):
from sympy.concrete.expr_with_limits import ForAll
if self.rhs.is_UNION:
return ForAll(self.func(self.lhs, self.rhs.function).simplify(),
*self.rhs.limits,
equivalent=self).simplify()
if self.rhs.is_FiniteSet:
eqs = []
for e in self.rhs.args:
eqs.append(Contains(e, self.lhs))
return And(*eqs, equivalent=self)
return self
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)
w = Symbol.w(integer=True, shape=(n, n, n, n), definition=LAMBDA[j:n, i:n](Swap(n, i, j)))
given = ForAll[x:S](Contains(w[0, j] @ x, S))
Eq << apply(given)
Eq.given_i = given.subs(j, i)
Eq << given.subs(x, Eq.given_i.function.lhs)
Eq << (Eq.given_i & Eq[-1]).split()[-1]
Eq << Eq.given_i.subs(x, Eq[-1].function.lhs)
Eq.final_statement = (Eq[-2] & Eq[-1]).split()[0]
Eq << swap2.equality.apply(n, w)
Eq << Eq[-1] @ x
Eq << Eq[-1].forall((Eq[-1].limits[0].args[1].args[1].arg,))
Eq.i_complement = Eq.final_statement.subs(Eq[-1])
Eq.plausible = ForAll(Contains(w[i, j] @ x, S), (x, S), (j, Interval(1, n - 1, integer=True)), plausible=True)
Eq << Eq.plausible.bisect(i.set, wrt=j)
Eq.i_complement, Eq.i_intersection = Eq[-1].split()
Eq << sets.imply.equality.intersection.apply(i, Interval(1, n - 1, integer=True))
Eq << Eq.i_intersection.this.limits[1].subs(Eq[-1])
Eq << Eq[-1].subs(w[i, i].equality_defined())
Eq << (Eq.i_complement & Eq.i_intersection)
Eq << elementary.swap.transpose.apply(w).subs(j, 0)
Eq << Eq.given_i.subs(Eq[-1].reversed)
Eq << (Eq[-1] & Eq.plausible)
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(
Contains(
LAMBDA[i:n](Piecewise((x[0], Equality(i, j)),
(x[j], Equality(i, 0)), (x[i], True))), S),
(j, 1, n - 1), (x, S))
Eq << apply(given)
w = Eq[0].lhs.base
Eq << swap1.utility.apply(x, w[0])
Eq << Eq[-1].reference(*Eq[-1].limits)
Eq.given = Eq[1].subs(Eq[-1].reversed)
Eq << axiom.algebre.matrix.elementary.swap.identity.apply(x, w)
Eq << Eq[-1].subs(Eq[-1].rhs.args[0].indices[0], 0)
Eq << Eq[-1].this.lhs.limits_subs(Eq[-1].lhs.variable, i)
Eq << Eq[-1].this.lhs.function.indices[0].args[1].limits_subs(
Eq[-1].lhs.function.indices[0].args[1].variable, i)
Eq << Eq[-1].subs(Eq[-1].rhs.args[0].indices[1], j)
Eq.given = Eq.given.subs(Eq[-1])
Eq << Eq.given.limits_swap()
Eq << ForAll[x:S](Eq[-1].function.subs(j, 0), plausible=True)
Eq << Eq[-1].subs(w[0, 0].this.definition)
Eq <<= Eq[-1] & Eq[-2]
Eq << combinatorics.permutation.adjacent.swap2.contains.apply(Eq[-1])
def apply(given):
assert given.is_ForAll
assert given.function.is_Equality
assert given.function.lhs.is_Limit
f, z, xi, direction = given.function.lhs.args
assert direction.name == '+-'
assert len(given.limits) == 1
limit = given.limits[0]
_xi, a, b = limit
assert xi == _xi
_f = f._subs(z, xi)
assert given.function.rhs == _f
y = Symbol.y(real=True)
return ForAll(Exists(Equality(f, y), (z, a, b)),
(y, MIN(f, (z, a, b)), MAX(f, (z, a, b))),
given=given)
def prove(Eq):
i = Symbol.i(integer=True)
j = Symbol.j(integer=True)
n = Symbol.n(domain=Interval(2, oo, integer=True))
baseset = Interval(0, n, integer=True)
assert Contains(0, baseset)
domain = n.set
assert n in baseset
assert baseset & domain == domain
x = Symbol.x(shape=(oo,), dtype=dtype.integer, finite=True)
i_domain = Interval(0, n - 1, integer=True)
Eq << apply(ForAll(Equality(x[i] & x[j], S.EmptySet), (j, i_domain - {i})))
Eq << Eq[-1].subs(n, 2).doit()
Eq << Eq[0].subs(i, 1)
Eq << Eq[-1].subs(j, 0)
Eq << sets.imply.equality.inclusion_exclusion_principle.apply(*Eq[-1].lhs.args).subs(Eq[-1])
Eq.plausible = Eq[1].subs(n, n + 1)
Eq << Eq.plausible.lhs.arg.this.bisect({n})
Eq << sets.imply.equality.inclusion_exclusion_principle.apply(*Eq[-1].rhs.args)
Eq << Eq[0].subs(i, n).limits_subs(j, i)
Eq << Eq[-1].union_comprehension((i, 0, n - 1))
Eq << Eq[-3].subs(Eq[-1])
Eq << Eq[-1].subs(Eq[1])
Eq << Eq.plausible.rhs.this.bisect({n})
Eq << Eq[-2].subs(Eq[-1].reversed)
def apply(*given):
subset, forall = given
if subset.is_ForAll:
forall, subset = subset, forall
assert subset.is_Subset and forall.is_ForAll
B, A = subset.args
index = -1
for i, (x, *domain) in enumerate(forall.limits):
if len(domain) == 1:
if domain[0] == A:
index = i
break
assert index >= 0
function = forall.function
limits = [*forall.limits]
limits[index] = (x, B)
return ForAll(function, *limits, given=given)
def apply(given):
assert given.is_Equality
x_union_intersect_A, emptyset = given.args
if emptyset != S.EmptySet:
tmp = emptyset
emptyset = x_union_intersect_A
x_union_intersect_A = tmp
assert emptyset == S.EmptySet
assert x_union_intersect_A.is_Intersection
x_union, A = x_union_intersect_A.args
if not x_union.is_UNION:
tmp = x_union
x_union = A
A = tmp
assert x_union.is_UNION
return ForAll(Equality(x_union.function & A, S.EmptySet),
*x_union.limits,
given=given)
def apply(*given):
contains, forall = given
assert contains.is_Contains and forall.is_ForAll
b, A = contains.args
index = -1
for i, (x, *domain) in enumerate(forall.limits):
if len(domain) == 1:
if domain[0] == A:
index = i
break
assert index >= 0
function = forall.function
function = function._subs(x, b) if x != b else function
limits = [*forall.limits]
del limits[index]
if limits:
return ForAll(function, *limits, given=given)
return function.copy(given=given)
def assertion(self):
from sympy.concrete.expr_with_limits import ForAll
return ForAll(self.condition, (self.variable, self))
def definition(self):
A, B = self.args
from sympy.concrete.expr_with_limits import ForAll
e = B.element_symbol(A.free_symbols)
return ForAll(Contains(e, B), (e, A), equivalent=self).simplify()
def prove(Eq):
k = Symbol.k(integer=True, positive=True)
n = Symbol.n(integer=True, positive=True)
Eq << apply(n, k)
s1_quote = Eq[1].lhs
Eq.s1_quote_definition = s1_quote.assertion()
i = Eq[0].lhs.indices[0]
x_tuple = Eq.s1_quote_definition.limits[0][0]
Eq.x_abs_positive_s1, Eq.x_abs_sum_s1, Eq.x_union_s1 = Eq.s1_quote_definition.split(
)
j = Symbol.j(domain=Interval(0, k, integer=True))
x_quote = Eq[0].lhs.base
Eq << Eq[0].union_comprehension((i, 0, k))
x_quote_union = Eq[-1].subs(Eq.x_union_s1)
Eq << x_quote_union
Eq << Eq[0].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])
# assert len(Eq.plausibles_dict) == 2
Eq.x_quote_definition = Eq[0].reference((i, 0, k))
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)
A_quote = Symbol.A_quote(shape=(k + 1, ),
dtype=dtype.integer.set.set,
definition=LAMBDA[j](Eq[2].rhs.function))
Eq.A_quote_definition = A_quote.this.definition
Eq.A_definition_simplified = Eq[2].this.rhs.subs(
Eq.A_quote_definition[j].reversed)
from sympy import S
j_quote = Symbol.j_quote(integer=True)
Eq.nonoverlapping = ForAll(
Equality(A_quote[j_quote] & A_quote[j], S.EmptySet),
*((j_quote, Interval(0, k, integer=True) - {j}), ) +
Eq.A_definition_simplified.rhs.limits,
plausible=True)
# assert len(Eq.plausibles_dict) == 4
Eq << ~Eq.nonoverlapping
Eq << Eq[-1].apply(sets.inequality.imply.exists.overlapping)
Eq << Eq[-1].subs(Eq.A_quote_definition[j])
Eq << Eq[-1].subs(Eq.A_quote_definition[j_quote])
Eq << Eq[-1].this.function.rhs.function.arg.definition
Eq << Eq[-1].apply(sets.equality.imply.supset)
Eq << Eq[-1].this.function.subs(Eq[-1].function.variable, Eq[-1].variable)
Eq << Eq[-1].definition
Eq << Eq[-1].subs(Eq.x_quote_definition)
Eq << Eq[-1].this.function.as_Or()
Eq << Eq[-1].split()
Eq << Eq[-1].split()[1].intersect({n})
Eq << Eq[-1].subs(Eq.nonoverlapping_s1_quote)
Eq << (Eq[-3] - n.set).limits_subs(j_quote, i)
Eq << Eq[-1].subs(Eq.xi_complement_n.subs(i, j)).subs(Eq.xi_complement_n)
_i = i.copy(domain=Interval(0, k, integer=True) - {j})
Eq << Eq[-1].limits_subs(i, _i)
Eq << Eq.x_union_s1.function.lhs.this.bisect({_i, j})
Eq << Eq[-1].subs(Eq[-2].reversed)
Eq << sets.imply.less_than.union_comprehension.apply(*Eq[-1].rhs.args)
Eq << Eq[-2].abs().subs(Eq.x_union_s1).subs(Eq[-1])
Eq << Eq[-1].subs(Eq.x_abs_sum_s1)
Eq << Eq[-1].subs(Eq.x_abs_positive_s1.subs(i, j))
# assert len(Eq.plausibles_dict) == 4
Eq << Eq.nonoverlapping.union_comprehension(Eq.nonoverlapping.limits[1])
Eq << Eq[-1].this.function.lhs.as_two_terms()
Eq << Eq.A_definition_simplified.subs(j, j_quote)
Eq << Eq[-2].subs(Eq[-1].reversed, Eq.A_definition_simplified.reversed)
Eq << sets.forall_equality.imply.equality.nonoverlapping.apply(Eq[-1])
Eq << Eq[-1].this.lhs.arg.limits_subs(j_quote, j)
Eq << Eq[-1].this.rhs.limits_subs(j_quote, j)
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)
