def test_depth():
assert (a | b).depth == 1
assert (a | (b & c)).depth == 2
assert (a | (b & (c | d))).depth == 3
assert (a & b).depth == 1
assert (a & (b | c)).depth == 2
assert (a & (b | (c & d))).depth == 3
assert Not(a | b).depth == 2
assert Not(a | (b & c)).depth == 3
assert Not(a | (b & (c | d))).depth == 4
assert Xor(a, b, c).depth == 1
assert Xor(a, b, c | d).depth == 2
assert Xor(a, b, c | Xor(d, e)).depth == 3
assert Equal(a, b, c).depth == 1
assert Equal(a, b, c | d).depth == 2
assert Equal(a, b, c | Xor(d, e)).depth == 3
assert Implies(p, q).depth == 1
assert Implies(p, a | b).depth == 2
assert Implies(p, Xor(a, b)).depth == 2
assert ITE(s, a, b).depth == 1
assert ITE(s, a | b, b).depth == 2
assert ITE(s, a | b, Xor(a, b)).depth == 2
def test_expr2dimacssat():
assert_raises(ValueError, expr2dimacssat, Xor(0, a, simplify=False))
ret = expr2dimacssat(Xor(a, ~b))
assert ret in {'p satx 2\nxor(-2 1)', 'p satx 2\nxor(1 -2)'}
ret = expr2dimacssat(Xor(a, Equal(b, ~c)))
assert ret in {
'p satex 3\nxor(=(2 -3) 1)', 'p satex 3\nxor(1 =(2 -3))',
'p satex 3\nxor(=(-3 2) 1)', 'p satex 3\nxor(1 =(-3 2))'
}
ret = expr2dimacssat(Equal(a, ~b))
assert ret in {'p sate 2\n=(1 -2)', 'p sate 2\n=(-2 1)'}
ret = expr2dimacssat(And(a, ~b))
assert ret in {'p sat 2\n*(1 -2)', 'p sat 2\n*(-2 1)'}
ret = expr2dimacssat(Or(a, ~b))
assert ret in {'p sat 2\n+(1 -2)', 'p sat 2\n+(-2 1)'}
ret = expr2dimacssat(Not(a | ~b))
assert ret in {'p sat 2\n-(+(1 -2))', 'p sat 2\n-(+(-2 1))'}
def test_basic():
a, b, c, d, p, q, s = map(exprvar, 'abcdpqs')
assert expr("a & ~b | b & ~c").equivalent(a & ~b | b & ~c)
assert expr("p => q").equivalent(~p | q)
assert expr("a <=> b").equivalent(~a & ~b | a & b)
assert expr("s ? a : b").equivalent(s & a | ~s & b)
assert expr("Not(a)").equivalent(Not(a))
assert expr("Or(a, b, c)").equivalent(Or(a, b, c))
assert expr("And(a, b, c)").equivalent(And(a, b, c))
assert expr("Xor(a, b, c)").equivalent(Xor(a, b, c))
assert expr("Xnor(a, b, c)").equivalent(Xnor(a, b, c))
assert expr("Equal(a, b, c)").equivalent(Equal(a, b, c))
assert expr("Unequal(a, b, c)").equivalent(Unequal(a, b, c))
assert expr("Implies(p, q)").equivalent(Implies(p, q))
assert expr("ITE(s, a, b)").equivalent(ITE(s, a, b))
assert expr("Nor(a, b, c)").equivalent(Nor(a, b, c))
assert expr("Nand(a, b, c)").equivalent(Nand(a, b, c))
assert expr("OneHot0(a, b, c)").equivalent(OneHot0(a, b, c))
assert expr("OneHot(a, b, c)").equivalent(OneHot(a, b, c))
assert expr("Majority(a, b, c)").equivalent(Majority(a, b, c))
assert expr("AchillesHeel(a, b, c, d)").equivalent(AchillesHeel(
a, b, c, d))
def test_equal():
assert Equal() is One
assert Equal(a) is One
assert Equal(0, 0) is One
assert Equal(0, 1) is Zero
assert Equal(1, 0) is Zero
assert Equal(1, 1) is One
assert Equal(0, 0, 0) is One
assert Equal(0, 0, 1) is Zero
assert Equal(0, 1, 0) is Zero
assert Equal(0, 1, 1) is Zero
assert Equal(1, 0, 0) is Zero
assert Equal(1, 0, 1) is Zero
assert Equal(1, 1, 0) is Zero
assert Equal(1, 1, 1) is One
assert Equal(a, 0) is ~a
assert Equal(1, a) is a
assert Equal(~a, a) is Zero
assert str(Equal(a, 0, simplify=False)) == "Equal(a, 0)"
assert str(Equal(1, a, simplify=False)) == "Equal(1, a)"
assert str(Equal(~a, a, simplify=False)) == "Equal(~a, a)"
def test_equal():
# Function
assert Equal(~a, b).support == {a, b}
# Expression
assert Equal() is EXPRONE
assert Equal(a) is EXPRONE
assert Equal(0, 0) is EXPRONE
assert Equal(0, 1) is EXPRZERO
assert Equal(1, 0) is EXPRZERO
assert Equal(1, 1) is EXPRONE
assert Equal(0, 0, 0) is EXPRONE
assert Equal(0, 0, 1) is EXPRZERO
assert Equal(0, 1, 0) is EXPRZERO
assert Equal(0, 1, 1) is EXPRZERO
assert Equal(1, 0, 0) is EXPRZERO
assert Equal(1, 0, 1) is EXPRZERO
assert Equal(1, 1, 0) is EXPRZERO
assert Equal(1, 1, 1) is EXPRONE
assert Equal(0, a) == ~a
assert Equal(a, 0) == ~a
assert Equal(1, a) == a
assert Equal(a, 1) == a
assert Equal(a, a) is EXPRONE
assert Equal(a, ~a) is EXPRZERO
assert Equal(~a, a) is EXPRZERO
assert Equal(a, b,
c).to_nnf(conj=False).equivalent(~a & ~b & ~c | a & b & c)
assert Equal(a, b,
c).to_nnf(conj=True).equivalent(~a & ~b & ~c | a & b & c)
def test_equal():
# Function
assert Equal(~a, b).support == {a, b}
# Expression
assert Equal() is One
assert Equal(a) is One
assert Equal(0, 0) is One
assert Equal(0, 1) is Zero
assert Equal(1, 0) is Zero
assert Equal(1, 1) is One
assert Equal(0, 0, 0) is One
assert Equal(0, 0, 1) is Zero
assert Equal(0, 1, 0) is Zero
assert Equal(0, 1, 1) is Zero
assert Equal(1, 0, 0) is Zero
assert Equal(1, 0, 1) is Zero
assert Equal(1, 1, 0) is Zero
assert Equal(1, 1, 1) is One
assert Equal(0, a) == ~a
assert Equal(a, 0) is ~a
assert Equal(1, a) is a
assert Equal(a, 1) is a
assert Equal(a, a) is One
assert Equal(a, ~a) is Zero
assert Equal(~a, a) is Zero
assert Equal(a, b, c).to_nnf().equivalent(~a & ~b & ~c | a & b & c)