def test_CheckOldAssump():
# TODO: Make these tests more complete
class Test1(Expr):
def _eval_is_extended_positive(self):
return True
def _eval_is_extended_negative(self):
return False
class Test2(Expr):
def _eval_is_finite(self):
return True
def _eval_is_extended_positive(self):
return True
def _eval_is_extended_negative(self):
return False
t1 = Test1()
t2 = Test2()
# We can't say if it's positive or negative in the old assumptions without
# bounded. Remember, True means "no new knowledge", and
# Q.positive(t2) means "t2 is positive."
assert CheckOldAssump(Q.positive(t1)) == to_NNF(True)
assert CheckOldAssump(Q.negative(t1)) == to_NNF(~Q.negative(t1))
assert CheckOldAssump(Q.positive(t2)) == to_NNF(Q.positive(t2))
assert CheckOldAssump(Q.negative(t2)) == to_NNF(~Q.negative(t2))
def test_AllArgs():
a = AllArgs(Q.zero)
b = AllArgs(Q.positive | Q.negative)
assert a.rcall(x * y) == to_NNF(And(Q.zero(x), Q.zero(y)))
assert b.rcall(x * y) == to_NNF(
And(Q.positive(x) | Q.negative(x),
Q.positive(y) | Q.negative(y)))
def test_AnyArgs():
a = AnyArgs(Q.zero)
b = AnyArgs(Q.positive & Q.negative)
assert a.rcall(x * y) == to_NNF(Or(Q.zero(x), Q.zero(y)))
assert b.rcall(x * y) == to_NNF(
Or(Q.positive(x) & Q.negative(x),
Q.positive(y) & Q.negative(y)))
def test_ExactlyOneArg():
a = ExactlyOneArg(Q.zero)
b = ExactlyOneArg(Q.positive | Q.negative)
assert a.rcall(x * y) == to_NNF(
Or(Q.zero(x) & ~Q.zero(y),
Q.zero(y) & ~Q.zero(x)))
assert a.rcall(x * y * z) == to_NNF(
Or(
Q.zero(x) & ~Q.zero(y) & ~Q.zero(z),
Q.zero(y)
& ~Q.zero(x) & ~Q.zero(z),
Q.zero(z) & ~Q.zero(x) & ~Q.zero(y)))
assert b.rcall(x * y) == to_NNF(
Or((Q.positive(x) | Q.negative(x)) & ~(Q.positive(y) | Q.negative(y)),
(Q.positive(y) | Q.negative(y)) & ~(Q.positive(x) | Q.negative(x))))
def apply(self, *args):
return to_NNF(self.lamda(*args), get_composite_predicates())
def apply(self, expr=None, is_Not=False):
from sympy import isprime
arg = self.args[0](expr) if callable(self.args[0]) else self.args[0]
res = Equivalent(arg, isprime(expr))
return to_NNF(res, get_composite_predicates())
def apply(self, expr=None, is_Not=False):
arg = self.args[0](expr) if callable(self.args[0]) else self.args[0]
res = Equivalent(arg, evaluate_old_assump(arg))
return to_NNF(res, get_composite_predicates())
def apply(self, expr=None):
if expr is None:
return
pred = to_NNF(self.pred, get_composite_predicates())
return self._eval_apply(expr, pred)
def apply(self, expr=None):
if expr is None:
return
pred = to_NNF(self.pred)
return self._eval_apply(expr, pred)
def apply(self, *args):
return to_NNF(self.lamda(*args))
