def test_simplify():
assert simplify(0) == 0
assert simplify(And(1, 1, 1, 0, simplify=False)) == 0
assert simplify(Or(0, 0, 0, 1, simplify=False)) == 1
f1 = And(a, And(b, And(c, 0, simplify=False), simplify=False), simplify=False)
f2 = Or(a, Or(b, Or(c, 1, simplify=False), simplify=False), simplify=False)
if MAJOR >= 3:
assert str(f1) == "a * b * c * 0"
assert str(f2) == "a + b + c + 1"
assert simplify(f1) == 0
assert simplify(f2) == 1
def test_implies():
# Function
assert Implies(-p, q).support == {p, q}
# Expression
assert Implies(0, 0) == 1
assert Implies(0, 1) == 1
assert Implies(1, 0) == 0
assert Implies(1, 1) == 1
assert (0 >> p) == 1
assert (1 >> p) == p
assert (p >> 0) == -p
assert (p >> 1) == 1
assert (p >> p) == 1
assert (p >> -p) == -p
assert (-p >> p) == p
assert str(p >> q) == "p => q"
assert str((a * b) >> (c + d)) == "(a * b) => (c + d)"
assert (p >> q).restrict({p: 0}) == 1
assert (p >> q).compose({q: a}).equivalent(p >> a)
assert (p >> q).invert().equivalent(p * -q)
assert ((a * b) >> (c + d)).depth == 2
f = Implies(p, 1, simplify=False)
assert str(f) == "p => 1"
assert simplify(f) == 1
assert f_implies(p, q).equivalent(-p + q)
def test_ite():
# Function
assert ITE(s, -a, b).support == {s, a, b}
# Expression
assert ITE(0, 0, 0) == 0
assert ITE(0, 0, 1) == 1
assert ITE(0, 1, 0) == 0
assert ITE(0, 1, 1) == 1
assert ITE(1, 0, 0) == 0
assert ITE(1, 0, 1) == 0
assert ITE(1, 1, 0) == 1
assert ITE(1, 1, 1) == 1
assert ITE(0, 0, b) == b
assert ITE(0, a, 0) == 0
assert ITE(0, 1, b) == b
assert ITE(0, a, 1) == 1
assert ITE(1, 0, b) == 0
assert ITE(1, a, 0) == a
assert ITE(1, 1, b) == 1
assert ITE(1, a, 1) == a
assert ITE(s, 0, 0) == 0
assert ITE(s, 0, 1) == -s
assert ITE(s, 1, 0) == s
assert ITE(s, 1, 1) == 1
assert ITE(s, 0, b).equivalent(-s * b)
assert ITE(s, a, 0).equivalent(s * a)
assert ITE(s, 1, b).equivalent(s + b)
assert ITE(s, a, 1).equivalent(-s + a)
assert ITE(s, -a, -a) == -a
assert ITE(s, a, a) == a
assert str(ITE(s, a, b)) == "s ? a : b"
assert str(ITE(s, a * b, c + d)) == "s ? (a * b) : (c + d)"
assert ITE(s, a, b).restrict({a: 1, b: 1}) == 1
assert ITE(s, a, b).compose({a: b, b: a}).equivalent(s * b + -s * a)
assert ITE(s, a, b).invert().equivalent((-s + -a) * (s + -b))
assert ITE(s, a * b, c + d).depth == 3
f = ITE(s, 1, 1, simplify=False)
assert str(f) == "s ? 1 : 1"
assert simplify(f) == 1
assert f_ite(s, a, b).equivalent(s * a + -s * b)
