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 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 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):
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)