def test_Not(): assert Not(Equality(x, y)) == Unequality(x, y) assert Not(Unequality(x, y)) == Equality(x, y) assert Not(StrictGreaterThan(x, y)) == LessThan(x, y) assert Not(StrictLessThan(x, y)) == GreaterThan(x, y) assert Not(GreaterThan(x, y)) == StrictLessThan(x, y) assert Not(LessThan(x, y)) == StrictGreaterThan(x, y)
def simplify(self, deep=False): e, s = self.args if s.is_FiniteSet: if len(s) == 1: y, *_ = s return Unequality(e, y, equivalent=self) return And(*(Unequality(e, y) for y in s), equivalent=self) if s.is_Interval and s.is_integer and e.is_Add: if S.NegativeOne in e.args: s += S.One e += S.One return self.func(e, s, evaluate=False, equivalent=self).simplify() if S.One in e.args: s -= S.One e -= S.One return self.func(e, s, evaluate=False, equivalent=self).simplify() domain = e.domain - s if domain.is_FiniteSet: return self.invert_type(e, domain).simplify() return self
def test_nan_equality_exceptions(): # See issue #7774 import random assert Equality(nan, nan) is S.false assert Unequality(nan, nan) is S.true # See issue #7773 A = (x, S.Zero, S.One / 3, pi, oo, -oo) assert Equality(nan, random.choice(A)) is S.false assert Equality(random.choice(A), nan) is S.false assert Unequality(nan, random.choice(A)) is S.true assert Unequality(random.choice(A), nan) is S.true
def apply(given): assert isinstance(given, GreaterThan) A_abs, positive = given.args assert A_abs.is_Abs and positive.is_positive A = A_abs.arg return Unequality(A, EmptySet(), given=given)
def test_core_relational(): x = Symbol("x") y = Symbol("y") for c in (Equality, Equality(x, y), Inequality, Inequality(x, y), Relational, Relational(x, y), StrictInequality, StrictInequality(x, y), Unequality, Unequality(x, y)): check(c)
def apply(given): assert isinstance(given, StrictGreaterThan) A_abs, zero = given.args assert A_abs.is_Abs and zero.is_zero A = A_abs.arg return Unequality(A, EmptySet(), given=given)
def test_core_relational(): x = Symbol("x") y = Symbol("y") for c in (Equality, Equality(x, y), GreaterThan, GreaterThan(x, y), LessThan, LessThan(x, y), Relational, Relational(x, y), StrictGreaterThan, StrictGreaterThan(x, y), StrictLessThan, StrictLessThan(x, y), Unequality, Unequality(x, y)): check(c)
def prove(Eq): x = Symbol.x(integer=True) y = Symbol.y(integer=True) Eq << apply(Unequality(x, y)) Eq << ~Eq[-1] Eq << Eq[-1].this.function.simplify() Eq << Eq[-1].subs(Eq[0])
def prove(Eq): A = Symbol.A(dtype=dtype.integer) inequality = Unequality(A, S.EmptySet, evaluate=False) Eq << apply(inequality) Eq << inequality.abs() Eq << GreaterThan(*Eq[-1].args, plausible=True) Eq << Eq[-1].subs(inequality)
def prove(Eq): s = Symbol.s(dtype=dtype.integer) e = Symbol.e(integer=True) Eq << apply(Unequality(e.set & s, S.EmptySet)) Eq << ~Eq[1] Eq << Eq[-1].apply(sets.notcontains.imply.equality.emptyset) Eq << Eq[-1].subs(Eq[0])
def prove(Eq): A = Symbol.A(dtype=dtype.integer) inequality = Unequality(A, S.EmptySet) Eq << apply(inequality) Eq << sets.inequality.imply.strict_greater_than.apply(inequality) Eq << ~Eq[1] Eq << Eq[-1].this.function.solve(Eq[-1].lhs) Eq << Eq[2].subs(Eq[-1])
def simplify(self, *_, **__): e, s = self.args if s.is_FiniteSet: if len(s) == 1: y, *_ = s from sympy import Symbol if not e._has(Symbol) and y._has(Symbol): return Equality(y, e, equivalent=self) return Equality(e, y, equivalent=self) # return Or(*(Equality(e, y) for y in s), equivalent=self) if s.is_ConditionSet: if e == s.variable: return s.condition.copy(equivalent=self) condition = s.condition._subs(s.variable, e) condition.equivalent = self return condition if s.is_Interval: if s.is_integer and e.is_Add: if not s.left_open or s.right_open: if S.NegativeOne in e.args: s += S.One e += S.One return self.func(e, s, evaluate=False, equivalent=self) if s.left_open or not s.right_open: if S.One in e.args: s -= S.One e -= S.One return self.func(e, s, evaluate=False, equivalent=self) if e.is_integer == s.is_integer: if s.start is S.NegativeInfinity: func = StrictLessThan if s.right_open else LessThan return func(e, s.stop, equivalent=self) if s.stop is S.Infinity: func = StrictGreaterThan if s.left_open else GreaterThan return func(e, s.start, equivalent=self) complement = e.domain - s if complement.is_FiniteSet: return self.invert_type(e, complement, equivalent=self).simplify() if s.is_Complement and s.args[1].is_FiniteSet and len(s.args[1]) == 1: domain_assumed = e.domain_assumed if domain_assumed and domain_assumed == s.args[0]: _e, *_ = s.args[1].args return Unequality(e, _e, equivalent=self) return self
def apply(*given, evaluate=False): assert len(given) == 2 A = None B = None for p in given: if p.is_Subset: A, B = p.args elif p.is_Unequality: _A, _B = p.args else: return assert A == _A and B == _B or A == _B and B == _A return Unequality(B - A, S.EmptySet, given=given, evaluate=evaluate)
def prove(Eq): A = Symbol.A(dtype=dtype.integer) B = Symbol.B(dtype=dtype.integer) inequality = Unequality(A & B, S.EmptySet) Eq << apply(inequality) Eq << (A & B).assertion() Eq << (Eq[-1] & inequality) Eq << Eq[-1].split() Eq << Eq[-1].split() Eq << (~Eq[1]).limits_subs(Eq[1].variable, Eq[-1].variable) Eq << (Eq[-1] & Eq[-3])
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): A = Symbol.A(dtype=dtype.integer) B = Symbol.B(dtype=dtype.integer) inequality = Unequality(A, B) subset = Subset(A, B, evaluate=False) Eq << apply(inequality, subset) Eq << ~Eq[-1] Eq << Eq[-1].union(A) Eq << Subset(B, A | B, plausible=True) Eq << Eq[-1].subs(Eq[-2]) Eq << Eq[-1].subs(subset).reversed Eq << Eq[-1].subs(Eq[0])
def test_Equality(): assert Equality(IM, IM) is S.true assert Unequality(IM, IM) is S.false assert Equality(IM, IM.subs(1, 2)) is S.false assert Unequality(IM, IM.subs(1, 2)) is S.true assert Equality(IM, 2) is S.false assert Unequality(IM, 2) is S.true M = ImmutableMatrix([x, y]) assert Equality(M, IM) is S.false assert Unequality(M, IM) is S.true assert Equality(M, M.subs(x, 2)).subs(x, 2) is S.true assert Unequality(M, M.subs(x, 2)).subs(x, 2) is S.false assert Equality(M, M.subs(x, 2)).subs(x, 3) is S.false assert Unequality(M, M.subs(x, 2)).subs(x, 3) is S.true
def test_relational(): if not np: skip("NumPy not installed") e = Equality(x, 1) f = lambdify((x, ), e) x_ = np.array([0, 1, 2]) assert np.array_equal(f(x_), [False, True, False]) e = Unequality(x, 1) f = lambdify((x, ), e) x_ = np.array([0, 1, 2]) assert np.array_equal(f(x_), [True, False, True]) e = (x < 1) f = lambdify((x, ), e) x_ = np.array([0, 1, 2]) assert np.array_equal(f(x_), [True, False, False]) e = (x <= 1) f = lambdify((x, ), e) x_ = np.array([0, 1, 2]) assert np.array_equal(f(x_), [True, True, False]) e = (x > 1) f = lambdify((x, ), e) x_ = np.array([0, 1, 2]) assert np.array_equal(f(x_), [False, False, True]) e = (x >= 1) f = lambdify((x, ), e) x_ = np.array([0, 1, 2]) assert np.array_equal(f(x_), [False, True, True])
def test_new_relational(): x = Symbol('x') assert Eq(x, 0) == Relational(x, 0) # None ==> Equality assert Eq(x, 0) == Relational(x, 0, '==') assert Eq(x, 0) == Relational(x, 0, 'eq') assert Eq(x, 0) == Equality(x, 0) assert Eq(x, 0) != Relational(x, 1) # None ==> Equality assert Eq(x, 0) != Relational(x, 1, '==') assert Eq(x, 0) != Relational(x, 1, 'eq') assert Eq(x, 0) != Equality(x, 1) assert Eq(x, -1) == Relational(x, -1) # None ==> Equality assert Eq(x, -1) == Relational(x, -1, '==') assert Eq(x, -1) == Relational(x, -1, 'eq') assert Eq(x, -1) == Equality(x, -1) assert Eq(x, -1) != Relational(x, 1) # None ==> Equality assert Eq(x, -1) != Relational(x, 1, '==') assert Eq(x, -1) != Relational(x, 1, 'eq') assert Eq(x, -1) != Equality(x, 1) assert Ne(x, 0) == Relational(x, 0, '!=') assert Ne(x, 0) == Relational(x, 0, '<>') assert Ne(x, 0) == Relational(x, 0, 'ne') assert Ne(x, 0) == Unequality(x, 0) assert Ne(x, 0) != Relational(x, 1, '!=') assert Ne(x, 0) != Relational(x, 1, '<>') assert Ne(x, 0) != Relational(x, 1, 'ne') assert Ne(x, 0) != Unequality(x, 1) assert Ge(x, 0) == Relational(x, 0, '>=') assert Ge(x, 0) == Relational(x, 0, 'ge') assert Ge(x, 0) == GreaterThan(x, 0) assert Ge(x, 1) != Relational(x, 0, '>=') assert Ge(x, 1) != Relational(x, 0, 'ge') assert Ge(x, 1) != GreaterThan(x, 0) assert (x >= 1) == Relational(x, 1, '>=') assert (x >= 1) == Relational(x, 1, 'ge') assert (x >= 1) == GreaterThan(x, 1) assert (x >= 0) != Relational(x, 1, '>=') assert (x >= 0) != Relational(x, 1, 'ge') assert (x >= 0) != GreaterThan(x, 1) assert Le(x, 0) == Relational(x, 0, '<=') assert Le(x, 0) == Relational(x, 0, 'le') assert Le(x, 0) == LessThan(x, 0) assert Le(x, 1) != Relational(x, 0, '<=') assert Le(x, 1) != Relational(x, 0, 'le') assert Le(x, 1) != LessThan(x, 0) assert (x <= 1) == Relational(x, 1, '<=') assert (x <= 1) == Relational(x, 1, 'le') assert (x <= 1) == LessThan(x, 1) assert (x <= 0) != Relational(x, 1, '<=') assert (x <= 0) != Relational(x, 1, 'le') assert (x <= 0) != LessThan(x, 1) assert Gt(x, 0) == Relational(x, 0, '>') assert Gt(x, 0) == Relational(x, 0, 'gt') assert Gt(x, 0) == StrictGreaterThan(x, 0) assert Gt(x, 1) != Relational(x, 0, '>') assert Gt(x, 1) != Relational(x, 0, 'gt') assert Gt(x, 1) != StrictGreaterThan(x, 0) assert (x > 1) == Relational(x, 1, '>') assert (x > 1) == Relational(x, 1, 'gt') assert (x > 1) == StrictGreaterThan(x, 1) assert (x > 0) != Relational(x, 1, '>') assert (x > 0) != Relational(x, 1, 'gt') assert (x > 0) != StrictGreaterThan(x, 1) assert Lt(x, 0) == Relational(x, 0, '<') assert Lt(x, 0) == Relational(x, 0, 'lt') assert Lt(x, 0) == StrictLessThan(x, 0) assert Lt(x, 1) != Relational(x, 0, '<') assert Lt(x, 1) != Relational(x, 0, 'lt') assert Lt(x, 1) != StrictLessThan(x, 0) assert (x < 1) == Relational(x, 1, '<') assert (x < 1) == Relational(x, 1, 'lt') assert (x < 1) == StrictLessThan(x, 1) assert (x < 0) != Relational(x, 1, '<') assert (x < 0) != Relational(x, 1, 'lt') assert (x < 0) != StrictLessThan(x, 1) # finally, some fuzz testing from sympy.core.random import randint for i in range(100): while 1: strtype, length = (chr, 65535) if randint(0, 1) else (chr, 255) relation_type = strtype(randint(0, length)) if randint(0, 1): relation_type += strtype(randint(0, length)) if relation_type not in ('==', 'eq', '!=', '<>', 'ne', '>=', 'ge', '<=', 'le', '>', 'gt', '<', 'lt', ':=', '+=', '-=', '*=', '/=', '%='): break raises(ValueError, lambda: Relational(x, 1, relation_type)) assert all(Relational(x, 0, op).rel_op == '==' for op in ('eq', '==')) assert all( Relational(x, 0, op).rel_op == '!=' for op in ('ne', '<>', '!=')) assert all(Relational(x, 0, op).rel_op == '>' for op in ('gt', '>')) assert all(Relational(x, 0, op).rel_op == '<' for op in ('lt', '<')) assert all(Relational(x, 0, op).rel_op == '>=' for op in ('ge', '>=')) assert all(Relational(x, 0, op).rel_op == '<=' for op in ('le', '<='))
def test_sympy__core__relational__Unequality(): from sympy.core.relational import Unequality assert _test_args(Unequality(x, 2))
def test_new_relational(): x = Symbol("x") assert Eq(x, 0) == Relational(x, 0) # None ==> Equality assert Eq(x, 0) == Relational(x, 0, "==") assert Eq(x, 0) == Relational(x, 0, "eq") assert Eq(x, 0) == Equality(x, 0) assert Eq(x, 0) != Relational(x, 1) # None ==> Equality assert Eq(x, 0) != Relational(x, 1, "==") assert Eq(x, 0) != Relational(x, 1, "eq") assert Eq(x, 0) != Equality(x, 1) assert Eq(x, -1) == Relational(x, -1) # None ==> Equality assert Eq(x, -1) == Relational(x, -1, "==") assert Eq(x, -1) == Relational(x, -1, "eq") assert Eq(x, -1) == Equality(x, -1) assert Eq(x, -1) != Relational(x, 1) # None ==> Equality assert Eq(x, -1) != Relational(x, 1, "==") assert Eq(x, -1) != Relational(x, 1, "eq") assert Eq(x, -1) != Equality(x, 1) assert Ne(x, 0) == Relational(x, 0, "!=") assert Ne(x, 0) == Relational(x, 0, "<>") assert Ne(x, 0) == Relational(x, 0, "ne") assert Ne(x, 0) == Unequality(x, 0) assert Ne(x, 0) != Relational(x, 1, "!=") assert Ne(x, 0) != Relational(x, 1, "<>") assert Ne(x, 0) != Relational(x, 1, "ne") assert Ne(x, 0) != Unequality(x, 1) assert Ge(x, 0) == Relational(x, 0, ">=") assert Ge(x, 0) == Relational(x, 0, "ge") assert Ge(x, 0) == GreaterThan(x, 0) assert Ge(x, 1) != Relational(x, 0, ">=") assert Ge(x, 1) != Relational(x, 0, "ge") assert Ge(x, 1) != GreaterThan(x, 0) assert (x >= 1) == Relational(x, 1, ">=") assert (x >= 1) == Relational(x, 1, "ge") assert (x >= 1) == GreaterThan(x, 1) assert (x >= 0) != Relational(x, 1, ">=") assert (x >= 0) != Relational(x, 1, "ge") assert (x >= 0) != GreaterThan(x, 1) assert Le(x, 0) == Relational(x, 0, "<=") assert Le(x, 0) == Relational(x, 0, "le") assert Le(x, 0) == LessThan(x, 0) assert Le(x, 1) != Relational(x, 0, "<=") assert Le(x, 1) != Relational(x, 0, "le") assert Le(x, 1) != LessThan(x, 0) assert (x <= 1) == Relational(x, 1, "<=") assert (x <= 1) == Relational(x, 1, "le") assert (x <= 1) == LessThan(x, 1) assert (x <= 0) != Relational(x, 1, "<=") assert (x <= 0) != Relational(x, 1, "le") assert (x <= 0) != LessThan(x, 1) assert Gt(x, 0) == Relational(x, 0, ">") assert Gt(x, 0) == Relational(x, 0, "gt") assert Gt(x, 0) == StrictGreaterThan(x, 0) assert Gt(x, 1) != Relational(x, 0, ">") assert Gt(x, 1) != Relational(x, 0, "gt") assert Gt(x, 1) != StrictGreaterThan(x, 0) assert (x > 1) == Relational(x, 1, ">") assert (x > 1) == Relational(x, 1, "gt") assert (x > 1) == StrictGreaterThan(x, 1) assert (x > 0) != Relational(x, 1, ">") assert (x > 0) != Relational(x, 1, "gt") assert (x > 0) != StrictGreaterThan(x, 1) assert Lt(x, 0) == Relational(x, 0, "<") assert Lt(x, 0) == Relational(x, 0, "lt") assert Lt(x, 0) == StrictLessThan(x, 0) assert Lt(x, 1) != Relational(x, 0, "<") assert Lt(x, 1) != Relational(x, 0, "lt") assert Lt(x, 1) != StrictLessThan(x, 0) assert (x < 1) == Relational(x, 1, "<") assert (x < 1) == Relational(x, 1, "lt") assert (x < 1) == StrictLessThan(x, 1) assert (x < 0) != Relational(x, 1, "<") assert (x < 0) != Relational(x, 1, "lt") assert (x < 0) != StrictLessThan(x, 1) # finally, some fuzz testing from random import randint from sympy.core.compatibility import unichr for i in range(100): while 1: strtype, length = (unichr, 65535) if randint(0, 1) else (chr, 255) relation_type = strtype(randint(0, length)) if randint(0, 1): relation_type += strtype(randint(0, length)) if relation_type not in ( "==", "eq", "!=", "<>", "ne", ">=", "ge", "<=", "le", ">", "gt", "<", "lt", ":=", "+=", "-=", "*=", "/=", "%=", ): break raises(ValueError, lambda: Relational(x, 1, relation_type)) assert all(Relational(x, 0, op).rel_op == "==" for op in ("eq", "==")) assert all(Relational(x, 0, op).rel_op == "!=" for op in ("ne", "<>", "!=")) assert all(Relational(x, 0, op).rel_op == ">" for op in ("gt", ">")) assert all(Relational(x, 0, op).rel_op == "<" for op in ("lt", "<")) assert all(Relational(x, 0, op).rel_op == ">=" for op in ("ge", ">=")) assert all(Relational(x, 0, op).rel_op == "<=" for op in ("le", "<="))
def replue(x, y): if bigger(x, y) in [True, False]: return True return Unequality(x, y)
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_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 test_new_relational(): x = Symbol('x') assert Eq(x) == Relational(x, 0) # None ==> Equality assert Eq(x) == Relational(x, 0, '==') assert Eq(x) == Relational(x, 0, 'eq') assert Eq(x) == Equality(x, 0) assert Eq(x, -1) == Relational(x, -1) # None ==> Equality assert Eq(x, -1) == Relational(x, -1, '==') assert Eq(x, -1) == Relational(x, -1, 'eq') assert Eq(x, -1) == Equality(x, -1) assert Eq(x) != Relational(x, 1) # None ==> Equality assert Eq(x) != Relational(x, 1, '==') assert Eq(x) != Relational(x, 1, 'eq') assert Eq(x) != Equality(x, 1) assert Eq(x, -1) != Relational(x, 1) # None ==> Equality assert Eq(x, -1) != Relational(x, 1, '==') assert Eq(x, -1) != Relational(x, 1, 'eq') assert Eq(x, -1) != Equality(x, 1) assert Ne(x, 0) == Relational(x, 0, '!=') assert Ne(x, 0) == Relational(x, 0, '<>') assert Ne(x, 0) == Relational(x, 0, 'ne') assert Ne(x, 0) == Unequality(x, 0) assert Ne(x, 0) != Relational(x, 1, '!=') assert Ne(x, 0) != Relational(x, 1, '<>') assert Ne(x, 0) != Relational(x, 1, 'ne') assert Ne(x, 0) != Unequality(x, 1) assert Ge(x, 0) == Relational(x, 0, '>=') assert Ge(x, 0) == Relational(x, 0, 'ge') assert Ge(x, 0) == GreaterThan(x, 0) assert Ge(x, 1) != Relational(x, 0, '>=') assert Ge(x, 1) != Relational(x, 0, 'ge') assert Ge(x, 1) != GreaterThan(x, 0) assert (x >= 1) == Relational(x, 1, '>=') assert (x >= 1) == Relational(x, 1, 'ge') assert (x >= 1) == GreaterThan(x, 1) assert (x >= 0) != Relational(x, 1, '>=') assert (x >= 0) != Relational(x, 1, 'ge') assert (x >= 0) != GreaterThan(x, 1) assert Le(x, 0) == Relational(x, 0, '<=') assert Le(x, 0) == Relational(x, 0, 'le') assert Le(x, 0) == LessThan(x, 0) assert Le(x, 1) != Relational(x, 0, '<=') assert Le(x, 1) != Relational(x, 0, 'le') assert Le(x, 1) != LessThan(x, 0) assert (x <= 1) == Relational(x, 1, '<=') assert (x <= 1) == Relational(x, 1, 'le') assert (x <= 1) == LessThan(x, 1) assert (x <= 0) != Relational(x, 1, '<=') assert (x <= 0) != Relational(x, 1, 'le') assert (x <= 0) != LessThan(x, 1) assert Gt(x, 0) == Relational(x, 0, '>') assert Gt(x, 0) == Relational(x, 0, 'gt') assert Gt(x, 0) == StrictGreaterThan(x, 0) assert Gt(x, 1) != Relational(x, 0, '>') assert Gt(x, 1) != Relational(x, 0, 'gt') assert Gt(x, 1) != StrictGreaterThan(x, 0) assert (x > 1) == Relational(x, 1, '>') assert (x > 1) == Relational(x, 1, 'gt') assert (x > 1) == StrictGreaterThan(x, 1) assert (x > 0) != Relational(x, 1, '>') assert (x > 0) != Relational(x, 1, 'gt') assert (x > 0) != StrictGreaterThan(x, 1) assert Lt(x, 0) == Relational(x, 0, '<') assert Lt(x, 0) == Relational(x, 0, 'lt') assert Lt(x, 0) == StrictLessThan(x, 0) assert Lt(x, 1) != Relational(x, 0, '<') assert Lt(x, 1) != Relational(x, 0, 'lt') assert Lt(x, 1) != StrictLessThan(x, 0) assert (x < 1) == Relational(x, 1, '<') assert (x < 1) == Relational(x, 1, 'lt') assert (x < 1) == StrictLessThan(x, 1) assert (x < 0) != Relational(x, 1, '<') assert (x < 0) != Relational(x, 1, 'lt') assert (x < 0) != StrictLessThan(x, 1) # finally, some fuzz testing from random import randint for i in range(100): while 1: if sys.version_info[0] >= 3: strtype, length = (chr, 65535) if randint(0, 1) else (chr, 255) else: strtype, length = (unichr, 65535) if randint(0, 1) else (chr, 255) relation_type = strtype( randint(0, length) ) if randint(0, 1): relation_type += strtype( randint(0, length) ) if relation_type not in ('==', 'eq', '!=', '<>', 'ne', '>=', 'ge', '<=', 'le', '>', 'gt', '<', 'lt'): break raises(ValueError, lambda: Relational(x, 1, relation_type))
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)
(r"\lim_{x \rightarrow 3} a", Limit(a, x, 3)), (r"\lim_{x \Rightarrow 3} a", Limit(a, x, 3)), (r"\lim_{x \longrightarrow 3} a", Limit(a, x, 3)), (r"\lim_{x \Longrightarrow 3} a", Limit(a, x, 3)), (r"\lim_{x \to 3^{+}} a", Limit(a, x, 3, dir='+')), (r"\lim_{x \to 3^{-}} a", Limit(a, x, 3, dir='-')), (r"\infty", oo), (r"\lim_{x \to \infty} \frac{1}{x}", Limit(_Pow(x, -1), x, oo)), (r"\frac{d}{dx} x", Derivative(x, x)), (r"\frac{d}{dt} x", Derivative(x, t)), (r"f(x)", f(x)), (r"f(x, y)", f(x, y)), (r"f(x, y, z)", f(x, y, z)), (r"\frac{d f(x)}{dx}", Derivative(f(x), x)), (r"\frac{d\theta(x)}{dx}", Derivative(Function('theta')(x), x)), (r"x \neq y", Unequality(x, y)), (r"|x|", _Abs(x)), (r"||x||", _Abs(Abs(x))), (r"|x||y|", _Abs(x) * _Abs(y)), (r"||x||y||", _Abs(_Abs(x) * _Abs(y))), (r"\pi^{|xy|}", Symbol('pi')**_Abs(x * y)), (r"\int x dx", Integral(x, x)), (r"\int x d\theta", Integral(x, theta)), (r"\int (x^2 - y)dx", Integral(x**2 - y, x)), (r"\int x + a dx", Integral(_Add(x, a), x)), (r"\int da", Integral(1, a)), (r"\int_0^7 dx", Integral(1, (x, 0, 7))), (r"\int\limits_{0}^{1} x dx", Integral(x, (x, 0, 1))), (r"\int_a^b x dx", Integral(x, (x, a, b))), (r"\int^b_a x dx", Integral(x, (x, a, b))), (r"\int_{a}^b x dx", Integral(x, (x, a, b))),
def apply(x, y, z, n): return Unequality(x**n + y**n, z**n)