Introduce more efficient replacements for lall, lany and conde

Author: brandonwillard

symbolic_pymc/relations/__init__.py

@@ -1,7 +1,12 @@
-from unification import isvar
+from itertools import tee, chain
+from functools import reduce
+
+from toolz import interleave
+
+from unification import isvar, reify
 
 from kanren import eq
-from kanren.core import lallgreedy
+from kanren.core import goaleval
 from kanren.facts import Relation
 from kanren.goals import goalify
 from kanren.term import term, operator, arguments
@@ -20,13 +25,85 @@
 concat = goalify(lambda *args: "".join(args))
 
 
+def ldisj_seq(goals):
+    """Produce a goal that returns the appended state stream from all successful goal arguments.
+
+    In other words, it behaves like logical disjunction/OR for goals.
+    """
+
+    def ldisj_seq_goal(S):
+        nonlocal goals
+
+        goals, _goals = tee(goals)
+
+        yield from interleave(goaleval(g)(S) for g in _goals)
+
+    return ldisj_seq_goal
+
+
+def lconj_seq(goals):
+    """Produce a goal that returns the appended state stream in which all goals are necessarily successful.
+
+    In other words, it behaves like logical conjunction/AND for goals.
+    """
+
+    def lconj_seq_goal(S):
+        nonlocal goals
+
+        goals, _goals = tee(goals)
+
+        g0 = next(iter(_goals), None)
+
+        if g0 is None:
+            return
+
+        z0 = goaleval(g0)(S)
+
+        yield from reduce(lambda z, g: chain.from_iterable(map(goaleval(g), z)), _goals, z0)
+
+    return lconj_seq_goal
+
+
+def ldisj(*goals):
+    return ldisj_seq(goals)
+
+
+def lconj(*goals):
+    return lconj_seq(goals)
+
+
+def conde(*goals):
+    return ldisj_seq(lconj_seq(g) for g in goals)
+
+
+lall = lconj
+lany = ldisj
+
+
 def buildo(op, args, obj):
-    if not isvar(obj):
-        if not isvar(args):
-            args = etuplize(args, shallow=True)
-        oop, oargs = operator(obj), arguments(obj)
-        return lallgreedy(eq(op, oop), eq(args, oargs))
-    elif isvar(args) or isvar(op):
-        return conso(op, args, obj)
-    else:
-        return eq(obj, term(op, args))
+    """Construct a goal that relates an object and its rand + rators decomposition.
+
+    This version uses etuples.
+
+    """
+
+    def buildo_goal(S):
+        nonlocal op, args, obj
+
+        op, args, obj = reify((op, args, obj), S)
+
+        if not isvar(obj):
+
+            if not isvar(args):
+                args = etuplize(args, shallow=True)
+
+            oop, oargs = operator(obj), arguments(obj)
+
+            yield from lall(eq(op, oop), eq(args, oargs))(S)
+
+        elif isvar(args) or isvar(op):
+            yield from conso(op, args, obj)(S)
+        else:
+            yield from eq(obj, term(op, args))(S)
+
+    return buildo_goal

symbolic_pymc/relations/graph.py

@@ -7,9 +7,10 @@
 
 from kanren import eq
 from cons.core import ConsPair, ConsNull
-from kanren.core import conde, lall
 from kanren.goals import conso, fail
 
+from . import conde, lall
+
 from ..etuple import etuplize, ExpressionTuple
 
 
@@ -217,7 +218,7 @@ def graph_applyo(
         def preprocess_graph(x):
             return x
 
-    def _gapplyo(s):
+    def graph_applyo_goal(s):
 
         nonlocal in_graph, out_graph
 
@@ -256,4 +257,4 @@ def _gapplyo(s):
         g = goaleval(g)
         yield from g(s)
 
-    return _gapplyo
+    return graph_applyo_goal

tests/test_goals.py

@@ -0,0 +1,110 @@
+from unification import var
+
+from kanren import eq  # , run, lall
+# from kanren.core import goaleval
+
+from symbolic_pymc.relations import lconj, lconj_seq, ldisj, ldisj_seq, conde
+
+
+def test_lconj_basics():
+
+    res = list(lconj(eq(1, var('a')), eq(2, var('b')))({}))
+    assert res == [{var('a'): 1, var('b'): 2}]
+
+    res = list(lconj(eq(1, var('a')))({}))
+    assert res == [{var('a'): 1}]
+
+    res = list(lconj_seq([])({}))
+    assert res == []
+
+    res = list(lconj(eq(1, var('a')), eq(2, var('a')))({}))
+    assert res == []
+
+    res = list(lconj(eq(1, 2))({}))
+    assert res == []
+
+    res = list(lconj(eq(1, 1))({}))
+    assert res == [{}]
+
+
+def test_ldisj_basics():
+
+    res = list(ldisj(eq(1, var('a')))({}))
+    assert res == [{var('a'): 1}]
+
+    res = list(ldisj(eq(1, 2))({}))
+    assert res == []
+
+    res = list(ldisj(eq(1, 1))({}))
+    assert res == [{}]
+
+    res = list(ldisj(eq(1, var('a')), eq(1, var('a')))({}))
+    assert res == [{var('a'): 1}, {var('a'): 1}]
+
+    res = list(ldisj(eq(1, var('a')), eq(2, var('a')))({}))
+    assert res == [{var('a'): 1}, {var('a'): 2}]
+
+    res = list(ldisj_seq([])({}))
+    assert res == []
+
+
+def test_conde_basics():
+
+    res = list(conde([eq(1, var('a')), eq(2, var('b'))],
+                     [eq(1, var('b')), eq(2, var('a'))])({}))
+    assert res == [{var('a'): 1, var('b'): 2},
+                   {var('b'): 1, var('a'): 2}]
+
+    res = list(conde([eq(1, var('a')), eq(2, 1)],
+                     [eq(1, var('b')), eq(2, var('a'))])({}))
+    assert res == [{var('b'): 1, var('a'): 2}]
+
+    res = list(conde([eq(1, var('a')),
+                      conde([eq(11, var('aa'))],
+                            [eq(12, var('ab'))])],
+                     [eq(1, var('b')),
+                      conde([eq(111, var('ba')),
+                             eq(112, var('bb'))],
+                            [eq(121, var('bc'))])])({}))
+    assert res == [{var('a'): 1, var('aa'): 11},
+                   {var('b'): 1, var('ba'): 111, var('bb'): 112},
+                   {var('a'): 1, var('ab'): 12},
+                   {var('b'): 1, var('bc'): 121}]
+
+    res = list(conde([eq(1, 2)], [eq(1, 1)])({}))
+    assert res == [{}]
+
+    assert list(lconj(eq(1, 1))({})) == [{}]
+
+    res = list(lconj(conde([eq(1, 2)], [eq(1, 1)]))({}))
+    assert res == [{}]
+
+    res = list(lconj(conde([eq(1, 2)], [eq(1, 1)]),
+                     conde([eq(1, 2)], [eq(1, 1)]))({}))
+    assert res == [{}]
+
+# def test_short_circuit_lconj():
+#
+#     def one_bad_goal(goal_nums, good_goals=10, _eq=eq):
+#         for i in goal_nums:
+#             if i == good_goals:
+#                 def _g(S, i=i):
+#                     print('{} bad'.format(i))
+#                     yield from _eq(1, 2)(S)
+#
+#             else:
+#                 def _g(S, i=i):
+#                     print('{} good'.format(i))
+#                     yield from _eq(1, 1)(S)
+#
+#             yield _g
+#
+#     goal_nums = iter(range(20))
+#     run(0, var('q'), lall(*one_bad_goal(goal_nums)))
+#
+#     # `kanren`'s `lall` will necessarily exhaust the generator.
+#     next(goal_nums, None)
+#
+#     goal_nums = iter(range(20))
+#     run(0, var('q'), lconj(one_bad_goal(goal_nums)))
+#     next(goal_nums, None)

tests/test_graph.py

@@ -269,8 +269,10 @@ def test_graph_applyo_reverse():
     assert test_res == (
         # Expansion of the term's root
         etuple(add, 5, 5),
+        # Expansion in the term's arguments
+        etuple(mul, etuple(log, etuple(exp, 2)), etuple(log, etuple(exp, 5))),
         # Two step expansion at the root
-        etuple(log, etuple(exp, etuple(add, 5, 5))),
+        # etuple(log, etuple(exp, etuple(add, 5, 5))),
         # Expansion into a sub-term
         # etuple(mul, 2, etuple(log, etuple(exp, 5)))
     )