def test_relation_relation_different_lengths(self):
x = logic.Var('x')
y = logic.Var('y')
a = logic.Atom('a')
r = logic.Relation('likes', (x, y))
s = logic.Relation('likes', (x, a, y))
self.assertFalse(logic.unify(r, s, {}))
def test_var_var_both_bound_unequal(self):
x = logic.Var('x')
y = logic.Var('y')
a = logic.Atom('a')
b = logic.Atom('b')
bindings = {x: a, y: b}
self.assertFalse(logic.unify(x, y, bindings))
def test_relation_relation_different_lengths(self):
x = logic.Var('x')
y = logic.Var('y')
a = logic.Atom('a')
r = logic.Relation('likes', (x, y))
s = logic.Relation('likes', (x, a, y))
self.assertFalse(logic.unify(r, s, {}))
def test_var_var_both_bound_unequal(self):
x = logic.Var('x')
y = logic.Var('y')
a = logic.Atom('a')
b = logic.Atom('b')
bindings = {x: a, y: b}
self.assertFalse(logic.unify(x, y, bindings))
def test_relation_relation_ok(self):
x = logic.Var('x')
y = logic.Var('y')
a = logic.Atom('a')
b = logic.Atom('b')
r = logic.Relation('likes', (x, y))
s = logic.Relation('likes', (a, x))
self.assertEqual({x: a, y: a}, logic.unify(r, s, {}))
def test_relation_relation_different_args(self):
x = logic.Var('x')
y = logic.Var('y')
a = logic.Atom('a')
b = logic.Atom('b')
r = logic.Relation('likes', (x, a))
s = logic.Relation('likes', (y, b))
self.assertFalse(logic.unify(r, s, {}))
def test_relation_relation_different_args(self):
x = logic.Var('x')
y = logic.Var('y')
a = logic.Atom('a')
b = logic.Atom('b')
r = logic.Relation('likes', (x, a))
s = logic.Relation('likes', (y, b))
self.assertFalse(logic.unify(r, s, {}))
def test_relation_relation_ok(self):
x = logic.Var('x')
y = logic.Var('y')
a = logic.Atom('a')
b = logic.Atom('b')
r = logic.Relation('likes', (x, y))
s = logic.Relation('likes', (a, x))
self.assertEqual({x: a, y: a}, logic.unify(r, s, {}))
def test_var_var_both_resolve_to_relations(self):
x = logic.Var('x')
y = logic.Var('y')
bar = logic.Var('bar')
baz = logic.Atom('baz')
b = logic.Atom('b')
c = logic.Var('c')
r = logic.Relation('foo', (bar, baz))
s = logic.Relation('foo', (b, c))
bindings = {x: r, y: s, bar: b, c: baz}
self.assertEqual(bindings, logic.unify(x, y, {x: r, y: s}))
def test_var_var_both_resolve_to_relations(self):
x = logic.Var('x')
y = logic.Var('y')
bar = logic.Var('bar')
baz = logic.Atom('baz')
b = logic.Atom('b')
c = logic.Var('c')
r = logic.Relation('foo', (bar, baz))
s = logic.Relation('foo', (b, c))
bindings = {x: r, y: s, bar: b, c: baz}
self.assertEqual(bindings, logic.unify(x, y, {x: r, y: s}))
def test_clauses_different_heads(self):
joe = logic.Atom('joe')
judy = logic.Atom('judy')
jorge = logic.Atom('jorge')
x = logic.Var('x')
r = logic.Relation('likes', (joe, x))
s = logic.Relation('likes', (joe, judy))
t = logic.Relation('hates', (x, jorge))
c = logic.Clause(r, [s])
d = logic.Clause(t, [s])
self.assertFalse(logic.unify(c, d, {}))
def test_clauses_different_heads(self):
joe = logic.Atom('joe')
judy = logic.Atom('judy')
jorge = logic.Atom('jorge')
x = logic.Var('x')
r = logic.Relation('likes', (joe, x))
s = logic.Relation('likes', (joe, judy))
t = logic.Relation('hates', (x, jorge))
c = logic.Clause(r, [s])
d = logic.Clause(t, [s])
self.assertFalse(logic.unify(c, d, {}))
def test_clauses_different_bodies(self):
joe = logic.Atom('joe')
judy = logic.Atom('judy')
jorge = logic.Atom('jorge')
x = logic.Var('x')
y = logic.Var('y')
r = logic.Relation('likes', (joe, x))
s = logic.Relation('hates', (joe, judy))
t = logic.Relation('likes', (y, jorge))
u = logic.Relation('hates', (judy, joe))
v = logic.Relation('hates', (judy, x))
c = logic.Clause(r, [s, v])
d = logic.Clause(t, [s, u])
self.assertFalse(logic.unify(c, d, {}))
def test_clauses_ok(self):
joe = logic.Atom('joe')
judy = logic.Atom('judy')
jorge = logic.Atom('jorge')
x = logic.Var('x')
y = logic.Var('y')
r = logic.Relation('likes', (joe, x))
s = logic.Relation('hates', (joe, judy))
t = logic.Relation('likes', (y, jorge))
u = logic.Relation('hates', (judy, joe))
v = logic.Relation('hates', (judy, y))
c = logic.Clause(r, [s, v])
d = logic.Clause(t, [s, u])
self.assertEqual({x: jorge, y: joe}, logic.unify(c, d, {}))
def test_clauses_different_bodies(self):
joe = logic.Atom('joe')
judy = logic.Atom('judy')
jorge = logic.Atom('jorge')
x = logic.Var('x')
y = logic.Var('y')
r = logic.Relation('likes', (joe, x))
s = logic.Relation('hates', (joe, judy))
t = logic.Relation('likes', (y, jorge))
u = logic.Relation('hates', (judy, joe))
v = logic.Relation('hates', (judy, x))
c = logic.Clause(r, [s, v])
d = logic.Clause(t, [s, u])
self.assertFalse(logic.unify(c, d, {}))
def test_clauses_ok(self):
joe = logic.Atom('joe')
judy = logic.Atom('judy')
jorge = logic.Atom('jorge')
x = logic.Var('x')
y = logic.Var('y')
r = logic.Relation('likes', (joe, x))
s = logic.Relation('hates', (joe, judy))
t = logic.Relation('likes', (y, jorge))
u = logic.Relation('hates', (judy, joe))
v = logic.Relation('hates', (judy, y))
c = logic.Clause(r, [s, v])
d = logic.Clause(t, [s, u])
self.assertEqual({x: jorge, y: joe}, logic.unify(c, d, {}))
def test_recursive_rename(self):
list = logic.Var('list')
x = logic.Var('x')
y = logic.Var('y')
z = logic.Var('z')
member = logic.Clause(logic.Relation('member', (x, list)),
[logic.Relation('first', (list, y)),
logic.Relation('rest', (list, z)),
logic.Relation('member', (x, z))])
renamed = member.recursive_rename()
bindings = logic.unify(renamed, member, {})
self.assertTrue(x in bindings or x in bindings.values())
self.assertTrue(y in bindings or y in bindings.values())
self.assertTrue(z in bindings or z in bindings.values())
def test_recursive_rename(self):
list = logic.Var('list')
x = logic.Var('x')
y = logic.Var('y')
z = logic.Var('z')
member = logic.Clause(logic.Relation('member', (x, list)), [
logic.Relation('first', (list, y)),
logic.Relation('rest', (list, z)),
logic.Relation('member', (x, z))
])
renamed = member.recursive_rename()
bindings = logic.unify(renamed, member, {})
self.assertTrue(x in bindings or x in bindings.values())
self.assertTrue(y in bindings or y in bindings.values())
self.assertTrue(z in bindings or z in bindings.values())
def test_var_var_right_unbound(self):
x = logic.Var('x')
y = logic.Var('y')
a = logic.Atom('a')
bindings = {x: a}
self.assertEqual({x: a, y: a}, logic.unify(x, y, bindings))
def test_var_resolves_to_relation_var(self):
x = logic.Var('x')
y = logic.Var('y')
r = logic.Relation('foo', (logic.Var('bar'), logic.Atom('baz')))
bindings = {y: r, x: r}
self.assertEqual(bindings, logic.unify(x, y, {x: r}))
def test_var_relation(self):
x = logic.Var('x')
r = logic.Relation('foo', (logic.Var('bar'), logic.Atom('baz')))
bindings = {x: r}
self.assertEqual(bindings, logic.unify(x, r, {}))
def test_var_var_both_bound_equal(self):
x = logic.Var('x')
y = logic.Var('y')
a = logic.Atom('a')
bindings = {x: a, y: a}
self.assertEqual(bindings, logic.unify(x, y, bindings))
def test_var_relation(self):
x = logic.Var('x')
r = logic.Relation('foo', (logic.Var('bar'), logic.Atom('baz')))
bindings = {x: r}
self.assertEqual(bindings, logic.unify(x, r, {}))
def test_atom_atom_fail(self):
a = logic.Atom('a')
b = logic.Atom('b')
self.assertFalse(logic.unify(a, b, {}))
def test_atom_var_exists_fail(self):
a = logic.Atom('a')
b = logic.Atom('b')
x = logic.Var('x')
bindings = {x: b}
self.assertFalse(logic.unify(a, x, bindings))
def test_atom_var_new(self):
a = logic.Atom('a')
x = logic.Var('x')
self.assertEqual({x: a}, logic.unify(a, x, {}))
def test_atom_var_exists_fail(self):
a = logic.Atom('a')
b = logic.Atom('b')
x = logic.Var('x')
bindings = {x: b}
self.assertFalse(logic.unify(a, x, bindings))
def test_atom_var_exists_ok(self):
a = logic.Atom('a')
x = logic.Var('x')
bindings = {x: a}
self.assertEqual(bindings, logic.unify(a, x, bindings))
def test_atom_atom_fail(self):
a = logic.Atom('a')
b = logic.Atom('b')
self.assertFalse(logic.unify(a, b, {}))
def test_atom_atom_ok(self):
a = logic.Atom('a')
self.assertEqual({}, logic.unify(a, a, {}))
def test_atom_atom_ok(self):
a = logic.Atom('a')
self.assertEqual({}, logic.unify(a, a, {}))
def test_var_var_both_unbound(self):
x = logic.Var('x')
y = logic.Var('y')
self.assertEqual({x: y}, logic.unify(x, y, {}))
def test_atom_var_new(self):
a = logic.Atom('a')
x = logic.Var('x')
self.assertEqual({x: a}, logic.unify(a, x, {}))
def test_var_var_both_unbound(self):
x = logic.Var('x')
y = logic.Var('y')
self.assertEqual({x: y}, logic.unify(x, y, {}))
def test_atom_var_exists_ok(self):
a = logic.Atom('a')
x = logic.Var('x')
bindings = {x: a}
self.assertEqual(bindings, logic.unify(a, x, bindings))
def test_var_var_right_unbound(self):
x = logic.Var('x')
y = logic.Var('y')
a = logic.Atom('a')
bindings = {x: a}
self.assertEqual({x: a, y: a}, logic.unify(x, y, bindings))
def test_var_var_both_bound_equal(self):
x = logic.Var('x')
y = logic.Var('y')
a = logic.Atom('a')
bindings = {x: a, y: a}
self.assertEqual(bindings, logic.unify(x, y, bindings))
def test_var_resolves_to_relation_var(self):
x = logic.Var('x')
y = logic.Var('y')
r = logic.Relation('foo', (logic.Var('bar'), logic.Atom('baz')))
bindings = {y: r, x: r}
self.assertEqual(bindings, logic.unify(x, y, {x: r}))
