Rename and lapply_anyo and make it return max goal conjunctions first

The relation/goal `lapply_anyo` has been renamed to `seq_apply_anyo`.  It has
also been made to return the state with the maximum number of simultaneously
successful goals--for the given relation applied across both sequences--first.

Author: brandonwillard

symbolic_pymc/relations/graph.py

@@ -13,7 +13,7 @@
 from ..etuple import etuplize, ExpressionTuple
 
 
-def lapply_anyo(relation, l_in, l_out, null_type=False, skip_op=True):
+def seq_apply_anyo(relation, l_in, l_out, null_type=False, skip_op=True):
     """Apply a relation to at least one pair of corresponding elements in two sequences.
 
     Parameters
@@ -27,8 +27,10 @@ def lapply_anyo(relation, l_in, l_out, null_type=False, skip_op=True):
        will not be applied to the operators (i.e. the cars) of the inputs.
     """
 
-    def _lapply_anyo(relation, l_in, l_out, i_any, null_type, skip_cars=False):
-        def _goal(s):
+    # This is a customized (based on the initial call arguments) goal
+    # constructor
+    def _seq_apply_anyo(relation, l_in, l_out, i_any, null_type, skip_cars=False):
+        def seq_apply_anyo_sub_goal(s):
 
             nonlocal i_any, null_type
 
@@ -38,35 +40,57 @@ def _goal(s):
             o_car, o_cdr = var(), var()
 
             conde_branches = []
+
             if i_any or (isvar(l_in_rf) and isvar(l_out_rf)):
+                # Consider terminating the sequences when we've had at least
+                # one successful goal or when both sequences are logic variables.
                 conde_branches.append([eq(l_in_rf, null_type), eq(l_in_rf, l_out_rf)])
 
-            descend_branch = [
+            # Extract the CAR and CDR of each argument sequence; this is how we
+            # iterate through elements of the two sequences.
+            cons_parts_branch = [
                 goaleval(conso(i_car, i_cdr, l_in_rf)),
                 goaleval(conso(o_car, o_cdr, l_out_rf)),
             ]
 
-            conde_branches.append(descend_branch)
+            conde_branches.append(cons_parts_branch)
 
-            conde_2_branches = [
-                [eq(i_car, o_car), _lapply_anyo(relation, i_cdr, o_cdr, i_any, null_type)]
-            ]
+            conde_relation_branches = []
+
+            relation_branch = None
 
             if not skip_cars:
-                conde_2_branches.append(
-                    [relation(i_car, o_car), _lapply_anyo(relation, i_cdr, o_cdr, True, null_type)]
-                )
+                relation_branch = [
+                    # This case tries the relation continues on.
+                    relation(i_car, o_car),
+                    # In this conde clause, we can tell future calls to
+                    # seq_apply_anyo that we've had at least one successful
+                    # application of the relation (otherwise, this clause
+                    # would fail due to the above goal).
+                    _seq_apply_anyo(relation, i_cdr, o_cdr, True, null_type),
+                ]
+
+                conde_relation_branches.append(relation_branch)
+
+            base_branch = [
+                # This is the "base" case; it is used when, for example,
+                # the given relation isn't satisfied.
+                eq(i_car, o_car),
+                _seq_apply_anyo(relation, i_cdr, o_cdr, i_any, null_type),
+            ]
+
+            conde_relation_branches.append(base_branch)
 
-            descend_branch.append(conde(*conde_2_branches))
+            cons_parts_branch.append(conde(*conde_relation_branches))
 
             g = conde(*conde_branches)
             g = goaleval(g)
 
             yield from g(s)
 
-        return _goal
+        return seq_apply_anyo_sub_goal
 
-    def goal(s):
+    def seq_apply_anyo_init_goal(s):
 
         nonlocal null_type, skip_op
 
@@ -95,7 +119,7 @@ def goal(s):
                 else []
             )
 
-        g = _lapply_anyo(
+        g = _seq_apply_anyo(
             relation,
             l_in,
             l_out,
@@ -107,7 +131,7 @@ def goal(s):
 
         yield from g(s)
 
-    return goal
+    return seq_apply_anyo_init_goal
 
 
 def reduceo(relation, in_term, out_term):
@@ -183,7 +207,7 @@ def graph_applyo(
     out_graph: object
       The graph for which the right-hand side of a binary relation holds.
     preprocess_graph: callable (optional)
-      A unary function that produces an iterable upon which `lapply_anyo`
+      A unary function that produces an iterable upon which `seq_apply_anyo`
       can be applied in order to traverse a graph's subgraphs.  The default
       function converts the graph to expression-tuple form.
     """
@@ -223,7 +247,7 @@ def _gapplyo(s):
             # We will only include it when there actually are children, or when
             # we're dealing with a logic variable (e.g. and "generating"
             # children).
-            subgraphs_reduce_gl = lapply_anyo(_gapply, in_subgraphs, out_subgraphs)
+            subgraphs_reduce_gl = seq_apply_anyo(_gapply, in_subgraphs, out_subgraphs)
 
             conde_args += ([subgraphs_reduce_gl],)
 

symbolic_pymc/relations/theano/__init__.py

@@ -6,7 +6,7 @@
 from kanren.core import lall
 
 from .linalg import buildo
-from ..graph import graph_applyo, lapply_anyo
+from ..graph import graph_applyo, seq_apply_anyo
 from ...etuple import etuplize, etuple
 from ...theano.meta import mt
 
@@ -69,7 +69,9 @@ def non_obs_graph_applyo(relation, a, b):
         # Deconstruct the observed random variable
         (buildo, rv_op_lv, rv_args_lv, obs_rv_lv),
         # Apply relation to the RV's inputs
-        lapply_anyo(partial(tt_graph_applyo, relation), rv_args_lv, new_rv_args_lv, skip_op=False),
+        seq_apply_anyo(
+            partial(tt_graph_applyo, relation), rv_args_lv, new_rv_args_lv, skip_op=False
+        ),
         # Reconstruct the random variable
         (buildo, rv_op_lv, new_rv_args_lv, new_obs_rv_lv),
         # Reconstruct the observation

tests/test_graph.py

@@ -10,7 +10,7 @@
 from kanren.goals import isinstanceo
 
 from symbolic_pymc.etuple import etuple, ExpressionTuple
-from symbolic_pymc.relations.graph import reduceo, lapply_anyo, graph_applyo
+from symbolic_pymc.relations.graph import reduceo, seq_apply_anyo, graph_applyo
 
 
 class OrderedFunction(object):
@@ -88,52 +88,61 @@ def test_reduceo():
     assert res[1] == etuple(log, etuple(exp, etuple(log, etuple(exp, 1))))
 
 
-def test_lapply_anyo_types():
+def test_seq_apply_anyo_types():
     """Make sure that `applyo` preserves the types between its arguments."""
     q_lv = var()
-    res = run(1, q_lv, lapply_anyo(lambda x, y: eq(x, y), [1], q_lv))
+    res = run(1, q_lv, seq_apply_anyo(lambda x, y: eq(x, y), [1], q_lv))
     assert res[0] == [1]
-    res = run(1, q_lv, lapply_anyo(lambda x, y: eq(x, y), (1,), q_lv))
+    res = run(1, q_lv, seq_apply_anyo(lambda x, y: eq(x, y), (1,), q_lv))
     assert res[0] == (1,)
-    res = run(1, q_lv, lapply_anyo(lambda x, y: eq(x, y), etuple(1,), q_lv, skip_op=False))
+    res = run(1, q_lv, seq_apply_anyo(lambda x, y: eq(x, y), etuple(1,), q_lv, skip_op=False))
     assert res[0] == etuple(1,)
-    res = run(1, q_lv, lapply_anyo(lambda x, y: eq(x, y), q_lv, (1,)))
+    res = run(1, q_lv, seq_apply_anyo(lambda x, y: eq(x, y), q_lv, (1,)))
     assert res[0] == (1,)
-    res = run(1, q_lv, lapply_anyo(lambda x, y: eq(x, y), q_lv, [1]))
+    res = run(1, q_lv, seq_apply_anyo(lambda x, y: eq(x, y), q_lv, [1]))
     assert res[0] == [1]
-    res = run(1, q_lv, lapply_anyo(lambda x, y: eq(x, y), q_lv, etuple(1), skip_op=False))
+    res = run(1, q_lv, seq_apply_anyo(lambda x, y: eq(x, y), q_lv, etuple(1), skip_op=False))
     assert res[0] == etuple(1)
-    res = run(1, q_lv, lapply_anyo(lambda x, y: eq(x, y), [1, 2], [1, 2]))
+    res = run(1, q_lv, seq_apply_anyo(lambda x, y: eq(x, y), [1, 2], [1, 2]))
     assert len(res) == 1
-    res = run(1, q_lv, lapply_anyo(lambda x, y: eq(x, y), [1, 2], [1, 3]))
+    res = run(1, q_lv, seq_apply_anyo(lambda x, y: eq(x, y), [1, 2], [1, 3]))
     assert len(res) == 0
-    res = run(1, q_lv, lapply_anyo(lambda x, y: eq(x, y), [1, 2], (1, 2)))
+    res = run(1, q_lv, seq_apply_anyo(lambda x, y: eq(x, y), [1, 2], (1, 2)))
     assert len(res) == 0
-    res = run(0, q_lv, lapply_anyo(lambda x, y: eq(y, etuple(mul, 2, x)),
+    res = run(0, q_lv, seq_apply_anyo(lambda x, y: eq(y, etuple(mul, 2, x)),
                                    etuple(add, 1, 2), q_lv, skip_op=True))
     assert len(res) == 3
     assert all(r[0] == add for r in res)
 
 
-def test_lapply_misc():
+def test_seq_apply_anyo_misc():
     q_lv = var('q')
 
-    assert len(run(0, q_lv, lapply_anyo(eq, [1, 2, 3], [1, 2, 3]))) == 1
+    assert len(run(0, q_lv, seq_apply_anyo(eq, [1, 2, 3], [1, 2, 3]))) == 1
 
-    assert len(run(0, q_lv, lapply_anyo(eq, [1, 2, 3], [1, 3, 3]))) == 0
+    assert len(run(0, q_lv, seq_apply_anyo(eq, [1, 2, 3], [1, 3, 3]))) == 0
 
-    assert len(run(4, q_lv, lapply_anyo(math_reduceo, [etuple(mul, 2, var('x'))], q_lv))) == 0
+    def one_to_threeo(x, y):
+        return conde([eq(x, 1), eq(y, 3)])
 
-    test_res = run(4, q_lv, lapply_anyo(math_reduceo, [etuple(add, 2, 2), 1], q_lv))
+    res = run(0, q_lv, seq_apply_anyo(one_to_threeo,
+                                      [1, 2, 4, 1, 4, 1, 1],
+                                      q_lv))
+
+    assert res[0] == [3, 2, 4, 3, 4, 3, 3]
+
+    assert len(run(4, q_lv, seq_apply_anyo(math_reduceo, [etuple(mul, 2, var('x'))], q_lv))) == 0
+
+    test_res = run(4, q_lv, seq_apply_anyo(math_reduceo, [etuple(add, 2, 2), 1], q_lv))
     assert test_res == ([etuple(mul, 2, 2), 1],)
 
-    test_res = run(4, q_lv, lapply_anyo(math_reduceo, [1, etuple(add, 2, 2)], q_lv))
+    test_res = run(4, q_lv, seq_apply_anyo(math_reduceo, [1, etuple(add, 2, 2)], q_lv))
     assert test_res == ([1, etuple(mul, 2, 2)],)
 
-    test_res = run(4, q_lv, lapply_anyo(math_reduceo, q_lv, var('z')))
+    test_res = run(4, q_lv, seq_apply_anyo(math_reduceo, q_lv, var('z')))
     assert all(isinstance(r, list) for r in test_res)
 
-    test_res = run(4, q_lv, lapply_anyo(math_reduceo, q_lv, var('z'), tuple()))
+    test_res = run(4, q_lv, seq_apply_anyo(math_reduceo, q_lv, var('z'), tuple()))
     assert all(isinstance(r, tuple) for r in test_res)
 
 
@@ -153,11 +162,11 @@ def test_lapply_misc():
       ([etuple(mul, 2, 1), 5],
        [etuple(add, 1, 1), 5],
        [etuple(mul, 2, 1), etuple(log, etuple(exp, 5))]))])
-def test_lapply_anyo(test_input, test_output):
-    """Test `lapply_anyo` with fully ground terms (i.e. no logic variables)."""
+def test_seq_apply_anyo(test_input, test_output):
+    """Test `seq_apply_anyo` with fully ground terms (i.e. no logic variables)."""
     q_lv = var()
     test_res = run(0, q_lv,
-                   (lapply_anyo, full_math_reduceo, test_input, q_lv))
+                   (seq_apply_anyo, full_math_reduceo, test_input, q_lv))
 
     assert len(test_res) == len(test_output)
 
@@ -175,18 +184,18 @@ def test_lapply_anyo(test_input, test_output):
     assert test_res == test_output
 
 
-def test_lapply_anyo_reverse():
-    """Test `lapply_anyo` in "reverse" (i.e. specify the reduced form and generate the un-reduced form)."""
+def test_seq_apply_anyo_reverse():
+    """Test `seq_apply_anyo` in "reverse" (i.e. specify the reduced form and generate the un-reduced form)."""
     # Unbounded reverse
     q_lv = var()
     rev_input = [etuple(mul, 2, 1)]
-    test_res = run(4, q_lv, (lapply_anyo, math_reduceo, q_lv, rev_input))
+    test_res = run(4, q_lv, (seq_apply_anyo, math_reduceo, q_lv, rev_input))
     assert test_res == ([etuple(add, 1, 1)],
                         [etuple(log, etuple(exp, etuple(mul, 2, 1)))])
 
     # Guided reverse
     test_res = run(4, q_lv,
-                   (lapply_anyo, math_reduceo,
+                   (seq_apply_anyo, math_reduceo,
                     [etuple(add, q_lv, 1)],
                     [etuple(mul, 2, 1)]))
 
@@ -203,6 +212,15 @@ def test_graph_applyo_misc():
 
     assert len(run(0, q_lv, graph_applyo(eq, etuple(), etuple(), preprocess_graph=None))) == 1
 
+    def one_to_threeo(x, y):
+        return conde([eq(x, 1), eq(y, 3)])
+
+    res = run(0, q_lv, graph_applyo(one_to_threeo,
+                                    [1, [1, 2, 4], 2, [[4, 1, 1]], 1],
+                                    q_lv, preprocess_graph=None))
+
+    assert res[0] == [3, [3, 2, 4], 2, [[4, 3, 3]], 3]
+
 
 @pytest.mark.parametrize(
     'test_input, test_output',