def test_satisfy():
# Typical cases
f = a & ~b & c & ~d
assert EXPRZERO.satisfy_one() is None
assert EXPRONE.satisfy_one() == {}
assert f.satisfy_one() == {a: 1, b: 0, c: 1, d: 0}
# PLE solution
f = (a | b | c) & (~a | ~b | c)
assert f.satisfy_one() == {a: 0, b: 0, c: 1}
points = [p for p in Xor(a, b, c).satisfy_all()]
assert points == [
{a: 0, b: 0, c: 1},
{a: 0, b: 1, c: 0},
{a: 1, b: 0, c: 0},
{a: 1, b: 1, c: 1},
]
assert Xor(a, b, c).satisfy_count() == 4
# Assumptions
f = OneHot(a, b, c)
g = Xor(a, b, c)
with a, ~b:
assert f.satisfy_one() == {a: 1, b: 0, c: 0}
assert g.satisfy_one() == {a: 1, b: 0, c: 0}
with a & ~b:
assert f.satisfy_one() == {a: 1, b: 0, c: 0}
assert g.satisfy_one() == {a: 1, b: 0, c: 0}
def __init__(self):
self.X = exprvars('x', (1, 10), (1, 10), (1, 10))
V = And(*[
And(*[
OneHot(*[self.X[r, c, v] for v in range(1, 10)])
for c in range(1, 10)
]) for r in range(1, 10)
])
R = And(*[
And(*[
OneHot(*[self.X[r, c, v] for c in range(1, 10)])
for v in range(1, 10)
]) for r in range(1, 10)
])
C = And(*[
And(*[
OneHot(*[self.X[r, c, v] for r in range(1, 10)])
for v in range(1, 10)
]) for c in range(1, 10)
])
B = And(*[
And(*[
OneHot(*[
self.X[3 * br + r, 3 * bc + c, v] for r in range(1, 4)
for c in range(1, 4)
]) for v in range(1, 10)
]) for br in range(3) for bc in range(3)
])
self.litmap, self.S = expr2dimacscnf(And(V, R, C, B))
def test_satisfy():
# Typical cases
f = a & ~b & c & ~d
assert Zero.satisfy_one() is None
assert One.satisfy_one() == {}
assert f.satisfy_one() == {a: 1, b: 0, c: 1, d: 0}
# PLE solution
f = (a | b | c) & (~a | ~b | c)
assert f.satisfy_one() == {a: 0, b: 0, c: 1}
points = [p for p in Xor(a, b, c).satisfy_all()]
assert points == [
{
a: 0,
b: 0,
c: 1
},
{
a: 0,
b: 1,
c: 0
},
{
a: 1,
b: 0,
c: 0
},
{
a: 1,
b: 1,
c: 1
},
]
assert Xor(a, b, c).satisfy_count() == 4
# CNF SAT UNSAT
sat = Majority(a, b, c, conj=True)
unsat = Zero.expand([a, b, c], conj=True)
assert unsat.satisfy_one() is None
assert not list(unsat.satisfy_all())
assert list(sat.satisfy_all())
# Assumptions
f = OneHot(a, b, c)
g = Xor(a, b, c)
with a, ~b:
assert f.satisfy_one() == {a: 1, b: 0, c: 0}
assert g.satisfy_one() == {a: 1, b: 0, c: 0}
with a & ~b:
assert f.satisfy_one() == {a: 1, b: 0, c: 0}
assert g.satisfy_one() == {a: 1, b: 0, c: 0}
def test_onehot():
assert OneHot(0, 0, 0) is Zero
assert OneHot(0, 0, 1) is One
assert OneHot(0, 1, 0) is One
assert OneHot(0, 1, 1) is Zero
assert OneHot(1, 0, 0) is One
assert OneHot(1, 0, 1) is Zero
assert OneHot(1, 1, 0) is Zero
assert OneHot(1, 1, 1) is Zero
assert OneHot(a, b, c, conj=False).equivalent((~a | ~b) & (~a | ~c)
& (~b | ~c) & (a | b | c))
assert OneHot(a, b, c, conj=True).equivalent((~a | ~b) & (~a | ~c)
& (~b | ~c) & (a | b | c))
def test_onehot():
assert OneHot(0, 0, 0) is EXPRZERO
assert OneHot(0, 0, 1) is EXPRONE
assert OneHot(0, 1, 0) is EXPRONE
assert OneHot(0, 1, 1) is EXPRZERO
assert OneHot(1, 0, 0) is EXPRONE
assert OneHot(1, 0, 1) is EXPRZERO
assert OneHot(1, 1, 0) is EXPRZERO
assert OneHot(1, 1, 1) is EXPRZERO
assert OneHot(a, b, c).equivalent((~a | ~b) & (~a | ~c) & (~b | ~c)
& (a | b | c))
def test_satisfy():
# Typical cases
f = a & ~b & c & ~d
assert EXPRZERO.satisfy_one() is None
assert EXPRONE.satisfy_one() == {}
assert f.satisfy_one() == {a: 1, b: 0, c: 1, d: 0}
# PLE solution
f = (a | b | c) & (~a | ~b | c)
assert f.satisfy_one() == {a: 0, b: 0, c: 1}
points = [p for p in Xor(a, b, c).satisfy_all()]
assert points == [
{
a: 0,
b: 0,
c: 1
},
{
a: 0,
b: 1,
c: 0
},
{
a: 1,
b: 0,
c: 0
},
{
a: 1,
b: 1,
c: 1
},
]
assert Xor(a, b, c).satisfy_count() == 4
# Assumptions
f = OneHot(a, b, c)
g = Xor(a, b, c)
with a, ~b:
assert f.satisfy_one() == {a: 1, b: 0, c: 0}
assert g.satisfy_one() == {a: 1, b: 0, c: 0}
with a & ~b:
assert f.satisfy_one() == {a: 1, b: 0, c: 0}
assert g.satisfy_one() == {a: 1, b: 0, c: 0}
def test_satisfy():
# Typical cases
f = a & ~b & c & ~d
assert Zero.satisfy_one() is None
assert One.satisfy_one() == {}
assert f.satisfy_one() == {a: 1, b: 0, c: 1, d: 0}
# PLE solution
f = (a | b | c) & (~a | ~b | c)
assert f.satisfy_one() == {a: 0, b: 0, c: 1}
points = [p for p in Xor(a, b, c).satisfy_all()]
assert points == [
{a: 0, b: 0, c: 1},
{a: 0, b: 1, c: 0},
{a: 1, b: 0, c: 0},
{a: 1, b: 1, c: 1},
]
assert Xor(a, b, c).satisfy_count() == 4
# CNF SAT UNSAT
sat = Majority(a, b, c, conj=True)
unsat = Zero.expand([a, b, c], conj=True)
assert unsat.satisfy_one() is None
assert not list(unsat.satisfy_all())
assert list(sat.satisfy_all())
# Assumptions
f = OneHot(a, b, c)
g = Xor(a, b, c)
with a, ~b:
assert f.satisfy_one() == {a: 1, b: 0, c: 0}
assert g.satisfy_one() == {a: 1, b: 0, c: 0}
with a & ~b:
assert f.satisfy_one() == {a: 1, b: 0, c: 0}
assert g.satisfy_one() == {a: 1, b: 0, c: 0}
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))
