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)