def test_unify_variable_with_itself_should_not_unify():
# Regression test for https://github.com/logpy/logpy/issues/33
valido = Relation()
fact(valido, "a", "b")
fact(valido, "b", "a")
x = var()
assert run(0, x, valido(x, x)) == ()
def test_objects():
from logpy import variables, reify, assoccomm
assoccomm.op_registry.extend(op_registry)
fact(commutative, add)
fact(associative, add)
assert tuple(goaleval(eq_assoccomm(add(1, 2, 3), add(3, 1, 2)))({}))
assert tuple(goaleval(eq_assoccomm(add(1, 2, 3), add(3, 1, 2)))({}))
x = var('x')
print tuple(goaleval(eq_assoccomm(add(1, 2, 3), add(1, 2, x)))({}))
assert reify(x, tuple(goaleval(eq_assoccomm(add(1, 2, 3), add(1, 2,
x)))({}))[0]) == 3
assert reify(x, next(goaleval(eq_assoccomm(add(1, 2, 3), add(x, 2,
1)))({}))) == 3
v = add(1,2,3)
with variables(v):
x = add(5, 6)
print reify(v, next(goaleval(eq_assoccomm(v, x))({})))
assert reify(v, next(goaleval(eq_assoccomm(v, x))({}))) == x
del assoccomm.op_registry[-1]
def test_fact():
rel = Relation()
fact(rel, 1, 2)
assert (1, 2) in rel.facts
assert (10, 10) not in rel.facts
facts(rel, (2, 3), (3, 4))
assert (2, 3) in rel.facts
assert (3, 4) in rel.facts
def test_fact():
rel = Relation()
fact(rel, 1, 2)
assert (1, 2) in rel.facts
assert (10, 10) not in rel.facts
facts(rel, (2, 3), (3, 4))
assert (2, 3) in rel.facts
assert (3, 4) in rel.facts
def test_eq_assoccomm():
x, y = var(), var()
eqac = eq_assoccomm
ac = 'commassoc_op'
fact(commutative, ac)
fact(associative, ac)
assert results(eqac((ac, (ac, 1, x), y), (ac, 2, (ac, 3, 1))))
assert results((eqac, 1, 1))
assert results(eqac((a, (a, 1, 2), 3), (a, 1, 2, 3)))
assert results(eqac((ac, (ac, 1, 2), 3), (ac, 1, 2, 3)))
assert results(eqac((ac, 3, (ac, 1, 2)), (ac, 1, 2, 3)))
assert run(0, x, eqac((ac, 3, (ac, 1, 2)), (ac, 1, x, 3))) == (2,)
def test_eq_comm_object():
x = var('x')
fact(commutative, Add)
fact(associative, Add)
assert run(0, x, eq_comm(add(1, 2, 3), add(3, 1, x))) == (2, )
print(set(run(0, x, eq_comm(add(1, 2), x))))
assert set(run(0, x, eq_comm(add(1, 2), x))) == set((add(1, 2), add(2, 1)))
print(set(run(0, x, eq_assoccomm(add(1, 2, 3), add(1, x)))))
assert set(run(0, x, eq_assoccomm(add(1, 2, 3), add(1, x)))) == \
set((add(2, 3), add(3, 2)))
def test_eq_comm_object():
x = var('x')
fact(commutative, Add)
fact(associative, Add)
assert run(0, x, eq_comm(add(1, 2, 3), add(3, 1, x))) == (2, )
print(set(run(0, x, eq_comm(add(1, 2), x))))
assert set(run(0, x, eq_comm(add(1, 2), x))) == set((add(1, 2), add(2, 1)))
print(set(run(0, x, eq_assoccomm(add(1, 2, 3), add(1, x)))))
assert set(run(0, x, eq_assoccomm(add(1, 2, 3), add(1, x)))) == \
set((add(2, 3), add(3, 2)))
def test_eq_assoccomm():
x, y = var(), var()
eqac = eq_assoccomm
ac = 'commassoc_op'
fact(commutative, ac)
fact(associative, ac)
assert results(eqac(1, 1))
assert results(eqac((1, ), (1, )))
assert results(eqac((ac, (ac, 1, x), y), (ac, 2, (ac, 3, 1))))
assert results((eqac, 1, 1))
assert results(eqac((a, (a, 1, 2), 3), (a, 1, 2, 3)))
assert results(eqac((ac, (ac, 1, 2), 3), (ac, 1, 2, 3)))
assert results(eqac((ac, 3, (ac, 1, 2)), (ac, 1, 2, 3)))
assert run(0, x, eqac((ac, 3, (ac, 1, 2)), (ac, 1, x, 3))) == (2, )
def test_expr():
add = 'add'
mul = 'mul'
fact(commutative, add)
fact(associative, add)
fact(commutative, mul)
fact(associative, mul)
x, y = var('x'), var('y')
pattern = (mul, (add, 1, x), y) # (1 + x) * y
expr = (mul, 2, (add, 3, 1)) # 2 * (3 + 1)
assert run(0, (x,y), eq_assoccomm(pattern, expr)) == ((3, 2),)
def test_expr():
add = 'add'
mul = 'mul'
fact(commutative, Add)
fact(associative, Add)
fact(commutative, Mul)
fact(associative, Mul)
x, y = var('x'), var('y')
pattern = (mul, (add, 1, x), y) # (1 + x) * y
expr = (mul, 2, (add, 3, 1)) # 2 * (3 + 1)
assert run(0, (x, y), eq_assoccomm(pattern, expr)) == ((3, 2), )
def test_unify_variable_with_itself_should_unify():
valido = Relation()
fact(valido, 0, 1)
fact(valido, 1, 0)
fact(valido, 1, 1)
x = var()
assert run(0, x, valido(x, x)) == (1, )
def test_objects():
from logpy.unify import seq_registry, reify
class add(object):
def __init__(self, *args):
self.args = tuple(args)
def seq_add(x):
return (type(x),) + x.args
seq_registry.append((add, seq_add))
assert seq_add(add(1, 2, 3)) == (add, 1, 2, 3)
assert goaleval(eq_assoccomm(add(1, 2, 3), add(3, 1, 2)))({})
x = var('x')
assert tuple(goaleval(eq_assoccomm(add(1, 2, 3), add(1, 2, x)))({})) == ({x: 3},)
fact(commutative, add)
fact(associative, add)
assert reify(x, next(goaleval(eq_assoccomm(add(1, 2, 3), add(x, 2,
1)))({}))) == 3
seq_registry.pop()
def test_objects():
from logpy import variables, reify
fact(commutative, Add)
fact(associative, Add)
assert tuple(goaleval(eq_assoccomm(add(1, 2, 3), add(3, 1, 2)))({}))
assert tuple(goaleval(eq_assoccomm(add(1, 2, 3), add(3, 1, 2)))({}))
x = var('x')
print(tuple(goaleval(eq_assoccomm(add(1, 2, 3), add(1, 2, x)))({})))
assert reify(x, tuple(goaleval(eq_assoccomm(
add(1, 2, 3), add(1, 2, x)))({}))[0]) == 3
assert reify(x, next(goaleval(eq_assoccomm(
add(1, 2, 3), add(x, 2, 1)))({}))) == 3
v = add(1, 2, 3)
with variables(v):
x = add(5, 6)
print(reify(v, next(goaleval(eq_assoccomm(v, x))({}))))
assert reify(v, next(goaleval(eq_assoccomm(v, x))({}))) == x
def test_objects():
from logpy import variables, reify, assoccomm
fact(commutative, Add)
fact(associative, Add)
assert tuple(goaleval(eq_assoccomm(add(1, 2, 3), add(3, 1, 2)))({}))
assert tuple(goaleval(eq_assoccomm(add(1, 2, 3), add(3, 1, 2)))({}))
x = var('x')
print(tuple(goaleval(eq_assoccomm(add(1, 2, 3), add(1, 2, x)))({})))
assert reify(
x,
tuple(goaleval(eq_assoccomm(add(1, 2, 3), add(1, 2, x)))({}))[0]) == 3
assert reify(x,
next(goaleval(eq_assoccomm(add(1, 2, 3), add(x, 2,
1)))({}))) == 3
v = add(1, 2, 3)
with variables(v):
x = add(5, 6)
print(reify(v, next(goaleval(eq_assoccomm(v, x))({}))))
assert reify(v, next(goaleval(eq_assoccomm(v, x))({}))) == x
def test_unify_tuple():
# Tests that adding facts can be unified with unpacked versions of those
# facts.
valido = Relation()
fact(valido, (0, 1))
fact(valido, (1, 0))
fact(valido, (1, 1))
x = var()
y = var()
assert set(run(0, x, valido((x, y)))) == set([0, 1])
assert set(run(0, (x, y), valido((x, y)))) == set([(0, 1), (1, 0), (1, 1)])
assert run(0, x, valido((x, x))) == (1, )
def test_relation():
parent = Relation()
fact(parent, "Homer", "Bart")
fact(parent, "Homer", "Lisa")
fact(parent, "Marge", "Bart")
fact(parent, "Marge", "Lisa")
fact(parent, "Abe", "Homer")
fact(parent, "Jackie", "Marge")
x = var('x')
assert set(run(5, x, parent("Homer", x))) == set(("Bart", "Lisa"))
assert set(run(5, x, parent(x, "Bart"))) == set(("Homer", "Marge"))
def grandparent(x, z):
y = var()
return conde((parent(x, y), parent(y, z)))
assert set(run(5, x, grandparent(x, "Bart"))) == set(("Abe", "Jackie"))
foo = Relation('foo')
assert 'foo' in str(foo)
from logpy.core import var, run, eq, goaleval, EarlyGoalError
from logpy.facts import fact
from logpy.assoccomm import (associative, commutative, conde,
groupsizes_to_partition, assocunify, eq_comm,
eq_assoc, eq_assoccomm, assocsized, buildo,
op_args)
from logpy.util import raises
from logpy.dispatch import dispatch
a = 'assoc_op'
c = 'comm_op'
x = var()
fact(associative, a)
fact(commutative, c)
def results(g, s={}):
return tuple(goaleval(g)(s))
def test_eq_comm():
assert results(eq_comm(1, 1))
assert results(eq_comm((c, 1, 2, 3), (c, 1, 2, 3)))
assert results(eq_comm((c, 3, 2, 1), (c, 1, 2, 3)))
assert not results(eq_comm((a, 3, 2, 1), (a, 1, 2, 3))) # not commutative
assert not results(eq_comm((3, c, 2, 1), (c, 1, 2, 3)))
assert not results(eq_comm((c, 1, 2, 1), (c, 1, 2, 3)))
assert not results(eq_comm((a, 1, 2, 3), (c, 1, 2, 3)))
assert len(results(eq_comm((c, 3, 2, 1), x))) >= 6
from logpy.core import var, run, eq, goaleval, EarlyGoalError
from logpy.facts import fact
from logpy.assoccomm import (associative, commutative, conde,
groupsizes_to_partition, assocunify, eq_comm, eq_assoc,
eq_assoccomm, assocsized)
from logpy.util import raises
a = 'assoc_op'
c = 'comm_op'
x = var()
fact(associative, a)
fact(commutative, c)
def results(g, s={}):
return tuple(goaleval(g)(s))
def test_eq_comm():
assert results(eq_comm(1, 1))
assert results(eq_comm((c, 1, 2, 3), (c, 1, 2, 3)))
assert results(eq_comm((c, 3, 2, 1), (c, 1, 2, 3)))
assert not results(eq_comm((a, 3, 2, 1), (a, 1, 2, 3))) # not commutative
assert not results(eq_comm((3, c, 2, 1), (c, 1, 2, 3)))
assert not results(eq_comm((c, 1, 2, 1), (c, 1, 2, 3)))
assert not results(eq_comm((a, 1, 2, 3), (c, 1, 2, 3)))
assert len(results(eq_comm((c, 3, 2, 1), x))) >= 6
def test_eq_assoc():
assert results(eq_assoc(1, 1))
assert results(eq_assoc((a, 1, 2, 3), (a, 1, 2, 3)))
assert not results(eq_assoc((a, 3, 2, 1), (a, 1, 2, 3)))
assert results(eq_assoc((a, (a, 1, 2), 3), (a, 1, 2, 3)))
def test_relation():
parent = Relation()
fact(parent, "Homer", "Bart")
fact(parent, "Homer", "Lisa")
fact(parent, "Marge", "Bart")
fact(parent, "Marge", "Lisa")
fact(parent, "Abe", "Homer")
fact(parent, "Jackie", "Marge")
x = var('x')
assert set(run(5, x, parent("Homer", x))) == set(("Bart", "Lisa"))
assert set(run(5, x, parent(x, "Bart"))) == set(("Homer", "Marge"))
def grandparent(x, z):
y = var()
return conde((parent(x, y), parent(y, z)))
assert set(run(5, x, grandparent(x, "Bart"))) == set(("Abe", "Jackie"))
foo = Relation('foo')
assert 'foo' in str(foo)
