def Decision_Node_Answer(dnode, example, answer):
# test = unifiable(Test)
test = var()
tnode = var()
fnode = var()
# return conde(
# # (Decision_Answer_Node(dnode, answer), (unify, test, example), )
# # ((Decision_Answer_Node, dnode, answer), (unify, test, example), )
# ((Decision_Answer_Node, dnode, answer),)
# )
# return conde(
# (Decision_Answer_Node(dnode, answer), unify(example, var())),
# (Decision_Node(dnode, test, tnode, fnode),
# conde(
# (True, Decision_Node_Answer(tnode,example,answer), ),
# (Decision_Node_Answer(fnode,example,answer), )
# ), )
# )
return conde(((Decision_Answer_Node, dnode, answer), ), (
(Decision_Node, dnode, test, tnode, fnode),
conda((
(test, example),
(Decision_Node_Answer, tnode, example, answer),
), ((Decision_Node_Answer, fnode, example, answer), )),
))
def print_tree(self, node):
# print(node)
t = var()
t = run(1, t, Decision_Node_Test(node, t))
if not t:
self.print_answer_node(node)
return
print('Test for node', node, t)
l = var()
l = run(1, l, Tree_Node_LChild(node, l))
if l:
print(node, '-L->', l)
self.print_tree(l[0])
r = var()
r = run(1, r, Tree_Node_RChild(node, r))
if r:
print(node, '-R->', r)
self.print_tree(r[0])
def dot_add_subtree(self, dot, node):
t = var()
t = run(1, t, Decision_Node_Test(node, t))
if not t:
self.dot_add_answernode(dot, node)
return
#dotnode = self.quote_node(node)
print('t', t)
t = t[0]
# dot.node(node, str(t))
self.dot_node(dot, node, t)
l = var()
l = run(1, l, Tree_Node_LChild(node, l))[0]
if l:
print('l', l)
# dot.edge(dotnode, l)
self.dot_edge(dot, node, l)
self.dot_add_subtree(dot, l)
r = var()
r = run(1, r, Tree_Node_RChild(node, r))[0]
if r:
# dot.edge(dotnode, r)
self.dot_edge(dot, node, r)
self.dot_add_subtree(dot, r)
def _get_args(self, arg_types, typed_vars):
arg_lists = []
for argpos, (guide, typename) in enumerate(arg_types):
if guide == '+':
exist_vars = typed_vars[typename]
arg_lists.append(exist_vars)
elif guide == '-':
newvar = 'Var_' + typename + '_' + str(len(typed_vars[typename]))
newvar = var(newvar)
arg_lists.append([newvar])
elif guide == '#':
values = self._collect_type_values(typename)
arg_lists.append(values)
print('arg_lists', arg_lists)
return itertools.product(*arg_lists)
def age_lt(x, y):
v = var()
return (conde, ((age, x, v), (lt, v, y)))
def age_ge(x, y):
v = var()
print(x, y)
return (conde, ((age, x, v), (ge, v, y)))
def grandparent(x, z):
y = var()
return conde((parent(x, y), parent(y, z)))
from mykanren import run, eq, var, vars, conde
from mykanren import Relation, fact, facts
from numsys.number_relations import RegisteringRelation, ge, lt #, neg
parent = Relation()
facts(parent, ("Homer", "Bart"), ("Homer", "Lisa"), ("Abe", "Homer"))
x = var()
ans = run(2, x, eq(x, 5))
def grandparent(x, z):
y = var()
return conde((parent(x, y), parent(y, z)))
# print(ans)
# ================================================================================
from mykanren.assoccomm import eq_assoccomm as eq
from mykanren.assoccomm import commutative, associative
# Define some dummy Operationss
add = 'add'
mul = 'mul'
# Declare that these ops are commutative using the facts system
fact(commutative, mul)
def _add_target_vars(self, arg_types):
for guide, typename in arg_types:
newvar = 'Var_' + typename + '_' + str(len(self.target_typed_vars[typename]))
newvar = var(newvar)
self.target_typed_vars[typename].append(newvar)
def dot_add_answernode(self, dot, node):
ans = var()
ans = run(1, ans, Decision_Answer_Node(node, ans))[0]
# dot.node(self.quote_node(node), "%.3f: %s"%ans)
self.dot_node(dot, node, "%.3f: %s" % ans)
def print_answer_node(self, node):
ans = var()
ans = run(1, ans, Decision_Answer_Node(node, ans))
print(node, 'Answer:', ans)
def Decision_Tree_Answer(dtree, example, answer):
root = var()
return conde((
Tree_Root(dtree, root),
Decision_Node_Answer(root, example, answer),
))
