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 main():
x = logic.Var('x')
y = logic.Var('y')
a = logic.Var('a')
more = logic.Var('more')
member_first = logic.Clause(
logic.Relation('member', (x, logic.Relation('pair', (x, more)))))
member_last = logic.Clause(
logic.Relation('member', (x, logic.Relation('pair', (y, x)))))
member_rest = logic.Clause(
logic.Relation('member', (x, logic.Relation('pair', (y, more)))),
[logic.Relation('member', (x, more))])
db = {}
logic.store(db, member_first)
logic.store(db, member_last)
logic.store(db, member_rest)
print 'Database:'
print db
print
query = logic.Relation('member', (logic.Atom('foo'), x))
print 'Query:', query
print
logic.prolog_prove([query], db)
def test_lookup_search(self):
x = logic.Var('x')
y = logic.Var('y')
z = logic.Var('z')
w = logic.Atom('w')
bindings = {x: y, y: z, z: w}
self.assertEqual(w, x.lookup(bindings))
def main():
x = logic.Var('x')
y = logic.Var('y')
z = logic.Var('z')
a = logic.Var('a')
nil = logic.Atom('nil')
more = logic.Var('more')
zero = logic.Atom('0')
length_nil = logic.Clause(logic.Relation('length', (nil, zero)))
length_one = logic.Clause(
logic.Relation('length',
(logic.Relation('pair',
(x, more)), logic.Relation('+1', [a]))),
[logic.Relation('length', (more, a))])
db = {}
logic.store(db, length_nil)
logic.store(db, length_one)
print 'Database:'
print db
print
list = logic.Relation(
'pair',
(x, logic.Relation('pair', (y, logic.Relation('pair', (z, nil))))))
query = logic.Relation('length', (list, a))
print 'Query:', query
print
logic.prolog_prove([query], db)
def test_rename_vars(self):
v1 = logic.Var('x')
begin = logic.Var.counter
v2 = v1.rename_vars({v1: logic.Var.get_unused_var()})
self.assertEqual(logic.Var('var%d' % begin), v2)
self.assertEqual(begin + 1, logic.Var.counter)
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_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_get_vars(self):
a = logic.Atom('a')
x = logic.Var('x')
y = logic.Var('y')
p3 = logic.Relation('pair', (x, x))
p2 = logic.Relation('pair', (a, p3))
p1 = logic.Relation('pair', (y, p2))
self.assertEqual(set([x, y]), set(p1.get_vars()))
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_lookup_search_no_atom(self):
x = logic.Var('x')
y = logic.Var('y')
z = logic.Var('z')
bindings = {
x: y,
y: z,
}
self.assertEqual(z, x.lookup(bindings))
def test_bind_vars(self):
a = logic.Atom('a')
b = logic.Atom('b')
x = logic.Var('x')
y = logic.Var('y')
r = logic.Relation('likes', (a, x, y))
s = logic.Relation('likes', (a, b, y))
bindings = {x: b}
self.assertEqual(s, r.bind_vars(bindings))
def main():
x = logic.Var('x')
y = logic.Var('y')
z = logic.Var('z')
a = logic.Var('a')
nil = logic.Atom('nil')
more = logic.Var('more')
zero = logic.Atom('0')
length_nil = logic.Clause(logic.Relation('length', (nil, zero)))
length_one = logic.Clause(
logic.Relation('length',
(logic.Relation('pair',
(x, more)), logic.Relation('+1', [a]))),
[logic.Relation('length', (more, a))])
member_first = logic.Clause(
logic.Relation('member', (x, logic.Relation('pair', (x, more)))))
member_last = logic.Clause(
logic.Relation('member', (x, logic.Relation('pair', (y, x)))))
member_end = logic.Clause(
logic.Relation('member', (x, logic.Relation('pair', (x, nil)))))
member_rest = logic.Clause(
logic.Relation('member', (x, logic.Relation('pair', (y, more)))),
[logic.Relation('member', (x, more))])
db = {}
logic.store(db, length_nil)
logic.store(db, length_one)
logic.store(db, member_end)
logic.store(db, member_first)
logic.store(db, member_last)
logic.store(db, member_rest)
print 'Database:'
print db
print
four = logic.Relation('+1', [
logic.Relation('+1',
[logic.Relation('+1', [logic.Relation('+1', [zero])])])
])
foo = logic.Atom('foo')
has_foo = logic.Relation('member', (foo, x))
length_4 = logic.Relation('length', (x, a))
print 'Query:', has_foo, length_4
print
logic.prolog_prove([has_foo, length_4], db)
def test_get_vars(self):
a = logic.Atom('a')
b = logic.Atom('b')
x = logic.Var('x')
y = logic.Var('y')
z = logic.Var('z')
r = logic.Relation('likes', (a, x))
s = logic.Relation('likes', (y, b))
t = logic.Relation('hates', (x, z))
c = logic.Clause(r, (s, t))
self.assertEqual(set([x, y, z]), set(c.get_vars()))
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_length_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', (joe, jorge))
c = logic.Clause(r, [s])
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_rename_vars(self):
a = logic.Atom('a')
x = logic.Var('x')
y = logic.Var('y')
p2 = logic.Relation('pair', (a, y))
p1 = logic.Relation('pair', (x, p2))
vs = p1.get_vars()
begin = logic.Var.counter
rep = {v: logic.Var.get_unused_var() for v in vs}
u = logic.Var('var%d' % begin)
v = logic.Var('var%d' % (begin + 1))
r = logic.Relation('pair', [u, logic.Relation('pair', [a, v])])
self.assertEqual(r, p1.rename_vars(rep))
def test_prove_primitive_call(self):
joe = logic.Atom('joe')
judy = logic.Atom('judy')
jorge = logic.Atom('jorge')
x = logic.Var('x')
db = {'likes': [], 'hates': []}
db['likes'].append(
logic.Clause(logic.Relation('likes', (joe, x)), [
logic.Relation('likes', (x, joe)),
logic.Relation('hates', (judy, x))
]))
db['likes'].append(logic.Clause(logic.Relation('likes', (jorge, joe))))
db['hates'].append(logic.Clause(logic.Relation('hates',
(judy, jorge))))
things = []
def prim(a, b, c, d):
things.append(a)
db['prim'] = prim
goal = logic.Relation('likes', (joe, x))
display = logic.Relation('prim', 'foo')
bindings = logic.prove_all([goal, display], {}, db)
self.assertEqual(['foo'], things)
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 main():
#logging.basicConfig(level=logging.DEBUG)
db = {}
kim = logic.Atom('Kim')
robin = logic.Atom('Robin')
sandy = logic.Atom('Sandy')
lee = logic.Atom('Lee')
cats = logic.Atom('cats')
x = logic.Var('x')
sandy_likes = logic.Relation('likes', (sandy, x))
likes_cats = logic.Relation('likes', (x, cats))
sandy_likes_rule = logic.Clause(sandy_likes, [likes_cats])
kim_likes = logic.Relation('likes', (kim, x))
likes_lee = logic.Relation('likes', (x, lee))
likes_kim = logic.Relation('likes', (x, kim))
kim_likes_rule = logic.Clause(kim_likes, [likes_lee, likes_kim])
likes_self = logic.Clause(logic.Relation('likes', (x, x)))
klr = logic.Clause(logic.Relation('likes', (kim, robin)))
sll = logic.Clause(logic.Relation('likes', (sandy, lee)))
slk = logic.Clause(logic.Relation('likes', (sandy, kim)))
rlc = logic.Clause(logic.Relation('likes', (robin, cats)))
logic.store(db, sandy_likes_rule)
logic.store(db, kim_likes_rule)
logic.store(db, likes_self)
logic.store(db, klr)
logic.store(db, sll)
logic.store(db, slk)
logic.store(db, rlc)
print 'Database:'
print db
print
query = logic.Relation('likes', (sandy, logic.Var('who')))
print 'Query:', str(query)
print
logic.prolog_prove([query], db)
def main():
#logging.basicConfig(level=logging.DEBUG)
db = {}
kim = logic.Atom('Kim')
robin = logic.Atom('Robin')
sandy = logic.Atom('Sandy')
lee = logic.Atom('Lee')
cats = logic.Atom('cats')
x = logic.Var('x')
y = logic.Var('y')
z = logic.Var('z')
self_likes = logic.Clause(logic.Relation('likes', (x, x)))
transitive_likes = logic.Clause(
logic.Relation('likes', (x, y)),
(logic.Relation('likes', (x, z)), logic.Relation('likes', (z, y))))
klr = logic.Clause(logic.Relation('likes', (kim, robin)))
sll = logic.Clause(logic.Relation('likes', (sandy, lee)))
slk = logic.Clause(logic.Relation('likes', (sandy, kim)))
rlc = logic.Clause(logic.Relation('likes', (robin, cats)))
llr = logic.Clause(logic.Relation('likes', (lee, robin)))
logic.store(db, klr)
logic.store(db, sll)
logic.store(db, slk)
logic.store(db, rlc)
logic.store(db, llr)
logic.store(db, self_likes)
logic.store(db, transitive_likes)
print 'Database:'
print db
print
query = logic.Relation('likes', (sandy, logic.Var('who')))
print 'Query:', str(query)
print
logic.prolog_prove([query], db)
def test_bind_vars(self):
a = logic.Atom('a')
b = logic.Atom('b')
c = logic.Atom('c')
x = logic.Var('x')
y = logic.Var('y')
z = logic.Var('z')
r = logic.Relation('likes', (x, y, a))
s = logic.Relation('likes', (y, a, z))
t = logic.Relation('hates', (z, b, x))
bindings = {z: c, y: b, x: y}
cl1 = logic.Clause(r, (s, t))
cl2 = logic.Clause(
logic.Relation('likes', (b, b, a)),
(logic.Relation('likes',
(b, a, c)), logic.Relation('hates', (c, b, b))))
self.assertEqual(cl2, cl1.bind_vars(bindings))
def test_rename_vars(self):
x = logic.Var('x')
y = logic.Var('y')
z = logic.Var('z')
p = logic.Relation('pair', (y, logic.Relation('pair', (x, z))))
is_member = logic.Relation('member', (x, p))
is_list = logic.Relation('is_list', [p])
rule = logic.Clause(is_member, (is_list, p))
vs = rule.get_vars()
begin = logic.Var.counter
renames = {v: logic.Var.get_unused_var() for v in vs}
rule2 = rule.rename_vars(renames)
newx = renames[x]
newy = renames[y]
newz = renames[z]
new_list = logic.Relation('pair',
(newy, logic.Relation('pair', (newx, newz))))
rule3 = logic.Clause(logic.Relation('member', (newx, new_list)),
(logic.Relation('is_list', [new_list]), new_list))
self.assertEqual(rule3, rule2)
def test_prove_subgoals_required_fail(self):
joe = logic.Atom('joe')
judy = logic.Atom('judy')
jorge = logic.Atom('jorge')
x = logic.Var('x')
db = {'likes': [], 'hates': []}
db['likes'].append(
logic.Clause(logic.Relation('likes', (joe, x)), [
logic.Relation('likes', (x, joe)),
logic.Relation('hates', (judy, x))
]))
db['likes'].append(logic.Clause(logic.Relation('likes', (jorge, joe))))
db['hates'].append(logic.Clause(logic.Relation('hates', (judy, joe))))
goal = logic.Relation('likes', (joe, jorge))
bindings = logic.prove(goal, {}, db)
self.assertFalse(bindings)
def test_prove_all_no_subgoals_required(self):
joe = logic.Atom('joe')
judy = logic.Atom('judy')
jorge = logic.Atom('jorge')
x = logic.Var('x')
db = {'likes': [], 'hates': []}
db['likes'].append(
logic.Clause(logic.Relation('likes', (joe, x)), [
logic.Relation('likes', (x, joe)),
logic.Relation('hates', (judy, x))
]))
db['likes'].append(logic.Clause(logic.Relation('likes', (jorge, joe))))
db['hates'].append(logic.Clause(logic.Relation('hates',
(judy, jorge))))
goal1 = logic.Relation('likes', (x, joe))
goal2 = logic.Relation('hates', (judy, x))
bindings = logic.prove_all([goal1, goal2], {}, db)
self.assertEqual({x: jorge}, bindings)
def var(self):
self.match(QUESTION)
return logic.Var(self.match(IDENT))
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_rename_repeated_var(self):
x = logic.Var('x')
y = logic.Var('y')
r = logic.Relation('likes', (x, x))
s = logic.Relation('likes', (y, y))
self.assertEqual(s, r.rename_vars({x: y}))
def test_lookup_none(self):
bindings = {}
var = logic.Var('x')
self.assertEqual(None, var.lookup(bindings))
def test_get_vars(self):
x = logic.Var('x')
self.assertEqual([x], x.get_vars())
