def test_logic_not():
assert Not('a') == '!a'
assert Not('!a') == 'a'
# NOTE: we may want to change default Not behaviour and put this
# functionality into some method.
assert Not(And('a', 'b')) == Or('!a', '!b')
assert Not(Or('a', 'b')) == And('!a', '!b')
def test_logic_cmp():
l1 = And('a', Not('b'))
l2 = And('a', Not('b'))
assert hash(l1) == hash(l2)
assert (l1 == l2) == T
assert (l1 != l2) == F
assert And('a', 'b', 'c') == And('b', 'a', 'c')
assert And('a', 'b', 'c') == And('c', 'b', 'a')
assert And('a', 'b', 'c') == And('c', 'a', 'b')
def test_logic_expand():
t = And(Or('a','b'), 'c')
assert t.expand() == Or(And('a','c'), And('b','c'))
t = And(Or('a', Not('b')), 'b')
assert t.expand() == And('a','b')
t = And(Or('a','b'), Or('c','d'))
assert t.expand() == Or(And('a','c'), And('a','d'), And('b','c'), And('b','d'))
def test_deduce_alpha_implications():
def D(i):
I = deduce_alpha_implications(i)
P = rules_2prereq(
dict(((k, True), set([(v, True) for v in S]))
for k, S in I.items()))
return I, P
# transitivity
I, P = D([('a', 'b'), ('b', 'c')])
assert I == {'a': set(['b', 'c']), 'b': set(['c'])}
assert P == {'b': set(['a']), 'c': set(['a', 'b'])}
# see if the output does not contain repeated implications
I, P = D([('a', 'b'), ('b', 'c'), ('b', 'c')])
assert I == {'a': set(['b', 'c']), 'b': set(['c'])}
assert P == {'b': set(['a']), 'c': set(['a', 'b'])}
# see if it is tolerant to cycles
assert D([('a', 'a'), ('a', 'a')]) == ({}, {})
assert D([('a', 'b'), ('b', 'a')]) == ({
'a': set(['b']),
'b': set(['a'])
}, {
'a': set(['b']),
'b': set(['a'])
})
# see if it catches inconsistency
raises(ValueError, lambda: D([('a', Not('a'))]))
raises(ValueError, lambda: D([('a', 'b'), ('b', Not('a'))]))
raises(ValueError, lambda: D([('a', 'b'), ('b', 'c'), ('b', 'na'),
('na', Not('a'))]))
# something related to real-world
I, P = D([('rat', 'real'), ('int', 'rat')])
assert I == {'int': set(['rat', 'real']), 'rat': set(['real'])}
assert P == {'rat': set(['int']), 'real': set(['int', 'rat'])}
def test_logic_cmp():
l1 = And('a', Not('b'))
l2 = And('a', Not('b'))
assert hash(l1) == hash(l2)
assert (l1 == l2) == T
assert (l1 != l2) == F
assert And('a', 'b', 'c') == And('b', 'a', 'c')
assert And('a', 'b', 'c') == And('c', 'b', 'a')
assert And('a', 'b', 'c') == And('c', 'a', 'b')
assert Not('a') < Not('b')
assert (Not('b') < Not('a')) is False
if PY3:
assert (Not('a') < 2) is False
def test_logic_fromstring():
S = Logic.fromstring
assert S('a') == 'a'
assert S('!a') == Not('a')
assert S('a & b') == And('a', 'b')
assert S('a | b') == Or('a', 'b')
assert S('a | b & c') == And(Or('a', 'b'), 'c')
assert S('a & b | c') == Or(And('a', 'b'), 'c')
assert S('a & b & c') == And('a', 'b', 'c')
assert S('a | b | c') == Or('a', 'b', 'c')
raises(ValueError, lambda: S('| a'))
raises(ValueError, lambda: S('& a'))
raises(ValueError, lambda: S('a | | b'))
raises(ValueError, lambda: S('a | & b'))
raises(ValueError, lambda: S('a & & b'))
raises(ValueError, lambda: S('a |'))
def test_logic_xnotx():
assert And('a', Not('a')) == F
assert Or('a', Not('a')) == T
def test_logic_not():
assert Not('a') != '!a'
assert Not('!a') != 'a'
assert Not(True) == False
assert Not(False) == True
# NOTE: we may want to change default Not behaviour and put this
# functionality into some method.
assert Not(And('a', 'b')) == Or(Not('a'), Not('b'))
assert Not(Or('a', 'b')) == And(Not('a'), Not('b'))
raises(ValueError, lambda: Not(1))
def test_deduce_alpha_implications():
def D(i):
I = deduce_alpha_implications(i)
P = rules_2prereq(
dict(((k, True), {(v, True)
for v in S}) for k, S in I.items()))
return I, P
# transitivity
I, P = D([("a", "b"), ("b", "c")])
assert I == {
"a": set(["b", "c"]),
"b": set(["c"]),
Not("b"): set([Not("a")]),
Not("c"): set([Not("a"), Not("b")]),
}
assert P == {
"a": set(["b", "c"]),
"b": set(["a", "c"]),
"c": set(["a", "b"])
}
# Duplicate entry
I, P = D([("a", "b"), ("b", "c"), ("b", "c")])
assert I == {
"a": set(["b", "c"]),
"b": set(["c"]),
Not("b"): set([Not("a")]),
Not("c"): set([Not("a"), Not("b")]),
}
assert P == {
"a": set(["b", "c"]),
"b": set(["a", "c"]),
"c": set(["a", "b"])
}
# see if it is tolerant to cycles
assert D([("a", "a"), ("a", "a")]) == ({}, {})
assert D([("a", "b"), ("b", "a")]) == (
{
"a": set(["b"]),
"b": set(["a"]),
Not("a"): set([Not("b")]),
Not("b"): set([Not("a")]),
},
{
"a": set(["b"]),
"b": set(["a"])
},
)
# see if it catches inconsistency
raises(ValueError, lambda: D([("a", Not("a"))]))
raises(ValueError, lambda: D([("a", "b"), ("b", Not("a"))]))
raises(ValueError, lambda: D([("a", "b"), ("b", "c"), ("b", "na"),
("na", Not("a"))]))
# see if it handles implications with negations
I, P = D([("a", Not("b")), ("c", "b")])
assert I == {
"a": set([Not("b"), Not("c")]),
"b": set([Not("a")]),
"c": set(["b", Not("a")]),
Not("b"): set([Not("c")]),
}
assert P == {
"a": set(["b", "c"]),
"b": set(["a", "c"]),
"c": set(["a", "b"])
}
I, P = D([(Not("a"), "b"), ("a", "c")])
assert I == {
"a": set(["c"]),
Not("a"): set(["b"]),
Not("b"): set(["a", "c"]),
Not("c"): set([Not("a"), "b"]),
}
assert P == {
"a": set(["b", "c"]),
"b": set(["a", "c"]),
"c": set(["a", "b"])
}
# Long deductions
I, P = D([("a", "b"), ("b", "c"), ("c", "d"), ("d", "e")])
assert I == {
"a": set(["b", "c", "d", "e"]),
"b": set(["c", "d", "e"]),
"c": set(["d", "e"]),
"d": set(["e"]),
Not("b"): set([Not("a")]),
Not("c"): set([Not("a"), Not("b")]),
Not("d"): set([Not("a"), Not("b"), Not("c")]),
Not("e"): set([Not("a"), Not("b"),
Not("c"), Not("d")]),
}
assert P == {
"a": set(["b", "c", "d", "e"]),
"b": set(["a", "c", "d", "e"]),
"c": set(["a", "b", "d", "e"]),
"d": set(["a", "b", "c", "e"]),
"e": set(["a", "b", "c", "d"]),
}
# something related to real-world
I, P = D([("rat", "real"), ("int", "rat")])
assert I == {
"int": set(["rat", "real"]),
"rat": set(["real"]),
Not("real"): set([Not("rat"), Not("int")]),
Not("rat"): set([Not("int")]),
}
assert P == {
"rat": set(["int", "real"]),
"real": set(["int", "rat"]),
"int": set(["rat", "real"]),
}
def test_apply_beta_to_alpha_route():
APPLY = apply_beta_to_alpha_route
# indicates empty alpha-chain with attached beta-rule #bidx
def Q(bidx):
return (set(), [bidx])
# x -> a &(a,b) -> x -- x -> a
A = {"x": set(["a"])}
B = [(And("a", "b"), "x")]
assert APPLY(A, B) == {"x": (set(["a"]), []), "a": Q(0), "b": Q(0)}
# x -> a &(a,!x) -> b -- x -> a
A = {"x": set(["a"])}
B = [(And("a", Not("x")), "b")]
assert APPLY(A, B) == {"x": (set(["a"]), []), Not("x"): Q(0), "a": Q(0)}
# x -> a b &(a,b) -> c -- x -> a b c
A = {"x": set(["a", "b"])}
B = [(And("a", "b"), "c")]
assert APPLY(A, B) == {
"x": (set(["a", "b", "c"]), []),
"a": Q(0),
"b": Q(0)
}
# x -> a &(a,b) -> y -- x -> a [#0]
A = {"x": set(["a"])}
B = [(And("a", "b"), "y")]
assert APPLY(A, B) == {"x": (set(["a"]), [0]), "a": Q(0), "b": Q(0)}
# x -> a b c &(a,b) -> c -- x -> a b c
A = {"x": set(["a", "b", "c"])}
B = [(And("a", "b"), "c")]
assert APPLY(A, B) == {
"x": (set(["a", "b", "c"]), []),
"a": Q(0),
"b": Q(0)
}
# x -> a b &(a,b,c) -> y -- x -> a b [#0]
A = {"x": set(["a", "b"])}
B = [(And("a", "b", "c"), "y")]
assert APPLY(A, B) == {
"x": (set(["a", "b"]), [0]),
"a": Q(0),
"b": Q(0),
"c": Q(0)
}
# x -> a b &(a,b) -> c -- x -> a b c d
# c -> d c -> d
A = {"x": set(["a", "b"]), "c": set(["d"])}
B = [(And("a", "b"), "c")]
assert APPLY(A, B) == {
"x": (set(["a", "b", "c", "d"]), []),
"c": (set(["d"]), []),
"a": Q(0),
"b": Q(0),
}
# x -> a b &(a,b) -> c -- x -> a b c d e
# c -> d &(c,d) -> e c -> d e
A = {"x": set(["a", "b"]), "c": set(["d"])}
B = [(And("a", "b"), "c"), (And("c", "d"), "e")]
assert APPLY(A, B) == {
"x": (set(["a", "b", "c", "d", "e"]), []),
"c": (set(["d", "e"]), []),
"a": Q(0),
"b": Q(0),
"d": Q(1),
}
# x -> a b &(a,y) -> z -- x -> a b y z
# &(a,b) -> y
A = {"x": set(["a", "b"])}
B = [(And("a", "y"), "z"), (And("a", "b"), "y")]
assert APPLY(A, B) == {
"x": (set(["a", "b", "y", "z"]), []),
"a": (set(), [0, 1]),
"y": Q(0),
"b": Q(1),
}
# x -> a b &(a,!b) -> c -- x -> a b
A = {"x": set(["a", "b"])}
B = [(And("a", Not("b")), "c")]
assert APPLY(A, B) == {
"x": (set(["a", "b"]), []),
"a": Q(0),
Not("b"): Q(0)
}
# !x -> !a !b &(!a,b) -> c -- !x -> !a !b
A = {Not("x"): set([Not("a"), Not("b")])}
B = [(And(Not("a"), "b"), "c")]
assert APPLY(A, B) == {
Not("x"): (set([Not("a"), Not("b")]), []),
Not("a"): Q(0),
"b": Q(0),
}
# x -> a b &(b,c) -> !a -- x -> a b
A = {"x": set(["a", "b"])}
B = [(And("b", "c"), Not("a"))]
assert APPLY(A, B) == {"x": (set(["a", "b"]), []), "b": Q(0), "c": Q(0)}
# x -> a b &(a, b) -> c -- x -> a b c p
# c -> p a
A = {"x": set(["a", "b"]), "c": set(["p", "a"])}
B = [(And("a", "b"), "c")]
assert APPLY(A, B) == {
"x": (set(["a", "b", "c", "p"]), []),
"c": (set(["p", "a"]), []),
"a": Q(0),
"b": Q(0),
}
def test_apply_beta_to_alpha_route():
APPLY = apply_beta_to_alpha_route
# indicates empty alpha-chain with attached beta-rule #bidx
def Q(bidx):
return (set(), [bidx])
# x -> a &(a,b) -> x -- x -> a
A = {'x': set(['a'])}
B = [(And('a', 'b'), 'x')]
assert APPLY(A, B) == {'x': (set(['a']), []), 'a': Q(0), 'b': Q(0)}
# x -> a &(a,!x) -> b -- x -> a
A = {'x': set(['a'])}
B = [(And('a', Not('x')), 'b')]
assert APPLY(A, B) == {'x': (set(['a']), []), Not('x'): Q(0), 'a': Q(0)}
# x -> a b &(a,b) -> c -- x -> a b c
A = {'x': set(['a', 'b'])}
B = [(And('a', 'b'), 'c')]
assert APPLY(A, B) == \
{'x': (set(['a', 'b', 'c']), []), 'a': Q(0), 'b': Q(0)}
# x -> a &(a,b) -> y -- x -> a [#0]
A = {'x': set(['a'])}
B = [(And('a', 'b'), 'y')]
assert APPLY(A, B) == {'x': (set(['a']), [0]), 'a': Q(0), 'b': Q(0)}
# x -> a b c &(a,b) -> c -- x -> a b c
A = {'x': set(['a', 'b', 'c'])}
B = [(And('a', 'b'), 'c')]
assert APPLY(A, B) == \
{'x': (set(['a', 'b', 'c']), []), 'a': Q(0), 'b': Q(0)}
# x -> a b &(a,b,c) -> y -- x -> a b [#0]
A = {'x': set(['a', 'b'])}
B = [(And('a', 'b', 'c'), 'y')]
assert APPLY(A, B) == \
{'x': (set(['a', 'b']), [0]), 'a': Q(0), 'b': Q(0), 'c': Q(0)}
# x -> a b &(a,b) -> c -- x -> a b c d
# c -> d c -> d
A = {'x': set(['a', 'b']), 'c': set(['d'])}
B = [(And('a', 'b'), 'c')]
assert APPLY(A, B) == {'x': (set(['a', 'b', 'c', 'd']), []),
'c': (set(['d']), []), 'a': Q(0), 'b': Q(0)}
# x -> a b &(a,b) -> c -- x -> a b c d e
# c -> d &(c,d) -> e c -> d e
A = {'x': set(['a', 'b']), 'c': set(['d'])}
B = [(And('a', 'b'), 'c'), (And('c', 'd'), 'e')]
assert APPLY(A, B) == {'x': (set(['a', 'b', 'c', 'd', 'e']), []),
'c': (set(['d', 'e']), []), 'a': Q(0), 'b': Q(0), 'd': Q(1)}
# x -> a b &(a,y) -> z -- x -> a b y z
# &(a,b) -> y
A = {'x': set(['a', 'b'])}
B = [(And('a', 'y'), 'z'), (And('a', 'b'), 'y')]
assert APPLY(A, B) == {'x': (set(['a', 'b', 'y', 'z']), []),
'a': (set(), [0, 1]), 'y': Q(0), 'b': Q(1)}
# x -> a b &(a,!b) -> c -- x -> a b
A = {'x': set(['a', 'b'])}
B = [(And('a', Not('b')), 'c')]
assert APPLY(A, B) == \
{'x': (set(['a', 'b']), []), 'a': Q(0), Not('b'): Q(0)}
# !x -> !a !b &(!a,b) -> c -- !x -> !a !b
A = {Not('x'): set([Not('a'), Not('b')])}
B = [(And(Not('a'), 'b'), 'c')]
assert APPLY(A, B) == \
{Not('x'): (set([Not('a'), Not('b')]), []), Not('a'): Q(0), 'b': Q(0)}
# x -> a b &(b,c) -> !a -- x -> a b
A = {'x': set(['a', 'b'])}
B = [(And('b', 'c'), Not('a'))]
assert APPLY(A, B) == {'x': (set(['a', 'b']), []), 'b': Q(0), 'c': Q(0)}
# x -> a b &(a, b) -> c -- x -> a b c p
# c -> p a
A = {'x': set(['a', 'b']), 'c': set(['p', 'a'])}
B = [(And('a', 'b'), 'c')]
assert APPLY(A, B) == {'x': (set(['a', 'b', 'c', 'p']), []),
'c': (set(['p', 'a']), []), 'a': Q(0), 'b': Q(0)}
def test_deduce_alpha_implications():
def D(i):
I = deduce_alpha_implications(i)
P = rules_2prereq(dict(
((k, True), set([(v, True) for v in S])) for k, S in I.items()))
return I, P
# transitivity
I, P = D([('a', 'b'), ('b', 'c')])
assert I == {'a': set(['b', 'c']), 'b': set(['c']), Not('b'):
set([Not('a')]), Not('c'): set([Not('a'), Not('b')])}
assert P == {'a': set(['b', 'c']), 'b': set(['a', 'c']), 'c': set(['a', 'b'])}
# Duplicate entry
I, P = D([('a', 'b'), ('b', 'c'), ('b', 'c')])
assert I == {'a': set(['b', 'c']), 'b': set(['c']), Not('b'): set([Not('a')]), Not('c'): set([Not('a'), Not('b')])}
assert P == {'a': set(['b', 'c']), 'b': set(['a', 'c']), 'c': set(['a', 'b'])}
# see if it is tolerant to cycles
assert D([('a', 'a'), ('a', 'a')]) == ({}, {})
assert D([('a', 'b'), ('b', 'a')]) == (
{'a': set(['b']), 'b': set(['a']), Not('a'): set([Not('b')]), Not('b'): set([Not('a')])},
{'a': set(['b']), 'b': set(['a'])})
# see if it catches inconsistency
raises(ValueError, lambda: D([('a', Not('a'))]))
raises(ValueError, lambda: D([('a', 'b'), ('b', Not('a'))]))
raises(ValueError, lambda: D([('a', 'b'), ('b', 'c'), ('b', 'na'),
('na', Not('a'))]))
# see if it handles implications with negations
I, P = D([('a', Not('b')), ('c', 'b')])
assert I == {'a': set([Not('b'), Not('c')]), 'b': set([Not('a')]), 'c': set(['b', Not('a')]), Not('b'): set([Not('c')])}
assert P == {'a': set(['b', 'c']), 'b': set(['a', 'c']), 'c': set(['a', 'b'])}
I, P = D([(Not('a'), 'b'), ('a', 'c')])
assert I == {'a': set(['c']), Not('a'): set(['b']), Not('b'): set(['a',
'c']), Not('c'): set([Not('a'), 'b']),}
assert P == {'a': set(['b', 'c']), 'b': set(['a', 'c']), 'c': set(['a', 'b'])}
# Long deductions
I, P = D([('a', 'b'), ('b', 'c'), ('c', 'd'), ('d', 'e')])
assert I == {'a': set(['b', 'c', 'd', 'e']), 'b': set(['c', 'd', 'e']),
'c': set(['d', 'e']), 'd': set(['e']), Not('b'): set([Not('a')]),
Not('c'): set([Not('a'), Not('b')]), Not('d'): set([Not('a'), Not('b'),
Not('c')]), Not('e'): set([Not('a'), Not('b'), Not('c'), Not('d')])}
assert P == {'a': set(['b', 'c', 'd', 'e']), 'b': set(['a', 'c', 'd',
'e']), 'c': set(['a', 'b', 'd', 'e']), 'd': set(['a', 'b', 'c', 'e']),
'e': set(['a', 'b', 'c', 'd'])}
# something related to real-world
I, P = D([('rat', 'real'), ('int', 'rat')])
assert I == {'int': set(['rat', 'real']), 'rat': set(['real']),
Not('real'): set([Not('rat'), Not('int')]), Not('rat'): set([Not('int')])}
assert P == {'rat': set(['int', 'real']), 'real': set(['int', 'rat']),
'int': set(['rat', 'real'])}