def test_Implies():
A, B, C = map(Boolean, symbols('ABC'))
raises(ValueError, "Implies(A,B,C)")
assert Implies(True, True) == True
assert Implies(True, False) == False
assert Implies(False, True) == True
assert Implies(False, False) == True
assert A >> B == B << A
def test_overloading():
"""Test that |, & are overloaded as expected"""
A, B, C = map(Boolean, symbols('ABC'))
assert A & B == And(A, B)
assert A | B == Or(A, B)
assert (A & B) | C == Or(And(A, B), C)
assert A >> B == Implies(A, B)
assert A << B == Implies(B, A)
assert ~A == Not(A)
def test_relational_logic_symbols():
# See issue 6204
assert (x < y) & (z < t) == And(x < y, z < t)
assert (x < y) | (z < t) == Or(x < y, z < t)
assert ~(x < y) == Not(x < y)
assert (x < y) >> (z < t) == Implies(x < y, z < t)
assert (x < y) << (z < t) == Implies(z < t, x < y)
assert (x < y) ^ (z < t) == Xor(x < y, z < t)
assert isinstance((x < y) & (z < t), And)
assert isinstance((x < y) | (z < t), Or)
assert isinstance(~(x < y), GreaterThan)
assert isinstance((x < y) >> (z < t), Implies)
assert isinstance((x < y) << (z < t), Implies)
assert isinstance((x < y) ^ (z < t), (Or, Xor))
def parse_logic(self, logic, switch_sides=False, convert_to_converse=False):
"""
Read the logic model and formulate the symbolic expression
:param logic A Logic model instance
:param switch_sides: if True, reverse the sides indicated by the
logic model's side field
:param convert_to_converse: if True, swap hyps and concs
:return: symbolic expression
"""
# FIXME: dumb hard coding
side_swap = {
0: 0,
1: 1,
2: 3,
3: 2,
4: 4
}
hyps = logic.hyps.all()
concs = logic.concs.all()
if convert_to_converse:
hyps, concs = concs, hyps
hyp_expr = []
conc_expr = []
# form expression for hypothesis
for pside in hyps:
if switch_sides is True:
pside.side = side_swap[pside.side]
hyp_expr.append(self.parse_pside(pside))
# form expression for conclusion
for pside in concs:
if switch_sides is True:
pside.side = side_swap[pside.side]
conc_expr.append(self.parse_pside(pside))
hyp_expr = And(*hyp_expr)
conc_expr = And(*conc_expr)
# FIXME: dumb hard coding
# is it an implication or an equivalence?
if logic.variety == 0:
return Implies(hyp_expr, conc_expr)
elif logic.variety == 1:
return Equivalent(hyp_expr, conc_expr)
def test_zero():
"""
Everything in this test doesn't work with the ask handlers, and most
things would be very difficult or impossible to make work under that
model.
"""
assert satask(Q.zero(x) | Q.zero(y), Q.zero(x * y)) is True
assert satask(Q.zero(x * y), Q.zero(x) | Q.zero(y)) is True
assert satask(Implies(Q.zero(x), Q.zero(x * y))) is True
# This one in particular requires computing the fixed-point of the
# relevant facts, because going from Q.nonzero(x*y) -> ~Q.zero(x*y) and
# Q.zero(x*y) -> Equivalent(Q.zero(x*y), Q.zero(x) | Q.zero(y)) takes two
# steps.
assert satask(Q.zero(x) | Q.zero(y), Q.nonzero(x * y)) is False
assert satask(Q.zero(x), Q.zero(x**2)) is True
def test_count_ops_non_visual():
def count(val):
return count_ops(val, visual=False)
assert count(x) == 0
assert count(x) is not S.Zero
assert count(x + y) == 1
assert count(x + y) is not S.One
assert count(x + y*x + 2*y) == 4
assert count({x + y: x}) == 1
assert count({x + y: S(2) + x}) is not S.One
assert count(Or(x,y)) == 1
assert count(And(x,y)) == 1
assert count(Not(x)) == 0
assert count(Nor(x,y)) == 1
assert count(Nand(x,y)) == 1
assert count(Xor(x,y)) == 3
assert count(Implies(x,y)) == 1
assert count(Equivalent(x,y)) == 1
assert count(ITE(x,y,z)) == 3
assert count(ITE(True,x,y)) == 0
def test_pretty_Boolean():
expr = Not(x, evaluate=False)
assert pretty(expr) == "Not(x)"
assert upretty(expr) == u"¬ x"
expr = And(x, y)
assert pretty(expr) == "And(x, y)"
assert upretty(expr) == u"x ∧ y"
expr = Or(x, y)
assert pretty(expr) == "Or(x, y)"
assert upretty(expr) == u"x ∨ y"
expr = Xor(x, y, evaluate=False)
assert pretty(expr) == "Xor(x, y)"
assert upretty(expr) == u"x ⊻ y"
expr = Nand(x, y, evaluate=False)
assert pretty(expr) == "Nand(x, y)"
assert upretty(expr) == u"x ⊼ y"
expr = Nor(x, y, evaluate=False)
assert pretty(expr) == "Nor(x, y)"
assert upretty(expr) == u"x ⊽ y"
expr = Implies(x, y, evaluate=False)
assert pretty(expr) == "Implies(x, y)"
assert upretty(expr) == u"x → y"
expr = Equivalent(x, y, evaluate=False)
assert pretty(expr) == "Equivalent(x, y)"
assert upretty(expr) == u"x ≡ y"
def test_eliminate_implications():
A, B, C = map(Boolean, symbols('A,B,C'))
assert eliminate_implications(Implies(A, B, evaluate=False)) == (~A) | B
assert eliminate_implications(A >> (C >> Not(B))) == Or(
Or(Not(B), Not(C)), Not(A))
def test_count_ops_visual():
ADD, MUL, POW, SIN, COS, EXP, AND, D, G, M = symbols(
'Add Mul Pow sin cos exp And Derivative Integral Sum'.upper())
DIV, SUB, NEG = symbols('DIV SUB NEG')
LT, LE, GT, GE, EQ, NE = symbols('LT LE GT GE EQ NE')
NOT, OR, AND, XOR, IMPLIES, EQUIVALENT, _ITE, BASIC, TUPLE = symbols(
'Not Or And Xor Implies Equivalent ITE Basic Tuple'.upper())
def count(val):
return count_ops(val, visual=True)
assert count(7) is S.Zero
assert count(S(7)) is S.Zero
assert count(-1) == NEG
assert count(-2) == NEG
assert count(S(2) / 3) == DIV
assert count(Rational(2, 3)) == DIV
assert count(pi / 3) == DIV
assert count(-pi / 3) == DIV + NEG
assert count(I - 1) == SUB
assert count(1 - I) == SUB
assert count(1 - 2 * I) == SUB + MUL
assert count(x) is S.Zero
assert count(-x) == NEG
assert count(-2 * x / 3) == NEG + DIV + MUL
assert count(Rational(-2, 3) * x) == NEG + DIV + MUL
assert count(1 / x) == DIV
assert count(1 / (x * y)) == DIV + MUL
assert count(-1 / x) == NEG + DIV
assert count(-2 / x) == NEG + DIV
assert count(x / y) == DIV
assert count(-x / y) == NEG + DIV
assert count(x**2) == POW
assert count(-x**2) == POW + NEG
assert count(-2 * x**2) == POW + MUL + NEG
assert count(x + pi / 3) == ADD + DIV
assert count(x + S.One / 3) == ADD + DIV
assert count(x + Rational(1, 3)) == ADD + DIV
assert count(x + y) == ADD
assert count(x - y) == SUB
assert count(y - x) == SUB
assert count(-1 / (x - y)) == DIV + NEG + SUB
assert count(-1 / (y - x)) == DIV + NEG + SUB
assert count(1 + x**y) == ADD + POW
assert count(1 + x + y) == 2 * ADD
assert count(1 + x + y + z) == 3 * ADD
assert count(1 + x**y + 2 * x * y + y**2) == 3 * ADD + 2 * POW + 2 * MUL
assert count(2 * z + y + x + 1) == 3 * ADD + MUL
assert count(2 * z + y**17 + x + 1) == 3 * ADD + MUL + POW
assert count(2 * z + y**17 + x + sin(x)) == 3 * ADD + POW + MUL + SIN
assert count(2 * z + y**17 + x +
sin(x**2)) == 3 * ADD + MUL + 2 * POW + SIN
assert count(2 * z + y**17 + x + sin(x**2) +
exp(cos(x))) == 4 * ADD + MUL + 2 * POW + EXP + COS + SIN
assert count(Derivative(x, x)) == D
assert count(Integral(x, x) + 2 * x / (1 + x)) == G + DIV + MUL + 2 * ADD
assert count(Sum(x, (x, 1, x + 1)) + 2 * x /
(1 + x)) == M + DIV + MUL + 3 * ADD
assert count(Basic()) is S.Zero
assert count({x + 1: sin(x)}) == ADD + SIN
assert count([x + 1, sin(x) + y, None]) == ADD + SIN + ADD
assert count({x + 1: sin(x), y: cos(x) + 1}) == SIN + COS + 2 * ADD
assert count({}) is S.Zero
assert count([x + 1, sin(x) * y, None]) == SIN + ADD + MUL
assert count([]) is S.Zero
assert count(Basic()) == 0
assert count(Basic(Basic(), Basic(x, x + y))) == ADD + 2 * BASIC
assert count(Basic(x, x + y)) == ADD + BASIC
assert [count(Rel(x, y, op)) for op in '< <= > >= == <> !='.split()
] == [LT, LE, GT, GE, EQ, NE, NE]
assert count(Or(x, y)) == OR
assert count(And(x, y)) == AND
assert count(Or(x, Or(y, And(z, a)))) == AND + OR
assert count(Nor(x, y)) == NOT + OR
assert count(Nand(x, y)) == NOT + AND
assert count(Xor(x, y)) == XOR
assert count(Implies(x, y)) == IMPLIES
assert count(Equivalent(x, y)) == EQUIVALENT
assert count(ITE(x, y, z)) == _ITE
assert count([Or(x, y), And(x, y), Basic(x + y)]) == ADD + AND + BASIC + OR
assert count(Basic(Tuple(x))) == BASIC + TUPLE
#It checks that TUPLE is counted as an operation.
assert count(Eq(x + y, S(2))) == ADD + EQ
def test_count_ops_visual():
ADD, MUL, POW, SIN, COS, EXP, AND, D, G = symbols(
'Add Mul Pow sin cos exp And Derivative Integral'.upper())
DIV, SUB, NEG = symbols('DIV SUB NEG')
OR, AND, IMPLIES, EQUIVALENT, BASIC, TUPLE = symbols(
'Or And Implies Equivalent Basic Tuple'.upper())
def count(val):
return count_ops(val, visual=True)
assert count(7) is S.Zero
assert count(S(7)) is S.Zero
assert count(-1) == NEG
assert count(-2) == NEG
assert count(S(2)/3) == DIV
assert count(pi/3) == DIV
assert count(-pi/3) == DIV + NEG
assert count(I - 1) == SUB
assert count(1 - I) == SUB
assert count(1 - 2*I) == SUB + MUL
assert count(x) is S.Zero
assert count(-x) == NEG
assert count(-2*x/3) == NEG + DIV + MUL
assert count(1/x) == DIV
assert count(1/(x*y)) == DIV + MUL
assert count(-1/x) == NEG + DIV
assert count(-2/x) == NEG + DIV
assert count(x/y) == DIV
assert count(-x/y) == NEG + DIV
assert count(x**2) == POW
assert count(-x**2) == POW + NEG
assert count(-2*x**2) == POW + MUL + NEG
assert count(x + pi/3) == ADD + DIV
assert count(x + S(1)/3) == ADD + DIV
assert count(x + y) == ADD
assert count(x - y) == SUB
assert count(y - x) == SUB
assert count(-1/(x - y)) == DIV + NEG + SUB
assert count(-1/(y - x)) == DIV + NEG + SUB
assert count(1 + x**y) == ADD + POW
assert count(1 + x + y) == 2*ADD
assert count(1 + x + y + z) == 3*ADD
assert count(1 + x**y + 2*x*y + y**2) == 3*ADD + 2*POW + 2*MUL
assert count(2*z + y + x + 1) == 3*ADD + MUL
assert count(2*z + y**17 + x + 1) == 3*ADD + MUL + POW
assert count(2*z + y**17 + x + sin(x)) == 3*ADD + POW + MUL + SIN
assert count(2*z + y**17 + x + sin(x**2)) == 3*ADD + MUL + 2*POW + SIN
assert count(2*z + y**17 + x + sin(
x**2) + exp(cos(x))) == 4*ADD + MUL + 2*POW + EXP + COS + SIN
assert count(Derivative(x, x)) == D
assert count(Integral(x, x) + 2*x/(1 + x)) == G + DIV + MUL + 2*ADD
assert count(Basic()) is S.Zero
assert count({x + 1: sin(x)}) == ADD + SIN
assert count([x + 1, sin(x) + y, None]) == ADD + SIN + ADD
assert count({x + 1: sin(x), y: cos(x) + 1}) == SIN + COS + 2*ADD
assert count({}) is S.Zero
assert count([x + 1, sin(x)*y, None]) == SIN + ADD + MUL
assert count([]) is S.Zero
assert count(Basic()) == 0
assert count(Basic(Basic(),Basic(x,x+y))) == ADD + 2*BASIC
assert count(Basic(x, x + y)) == ADD + BASIC
assert count(Or(x,y)) == OR
assert count(And(x,y)) == AND
assert count(And(x**y,z)) == AND + POW
assert count(Or(x,Or(y,And(z,a)))) == AND + 2*OR
assert count(Nor(x,y)) == AND
assert count(Nand(x,y)) == OR
assert count(Xor(x,y)) == 2*AND + OR
assert count(Implies(x,y)) == IMPLIES
assert count(Equivalent(x,y)) == EQUIVALENT
assert count(ITE(x,y,z)) == 2*AND + OR
assert count([Or(x,y), And(x,y), Basic(x+y)]) == ADD + AND + BASIC + OR
assert count(Basic(Tuple(x))) == BASIC + TUPLE
#It checks that TUPLE is counted as an operation.
assert count(Eq(x + y, S(2))) == ADD
def __mod__(self, other):
"""Use Implies to simulate the MOD operator"""
return Implies(self.symbol, _param_to_symbol(other))
