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)