def backchain_to_goal_tree(rules, hypothesis): treeNode = OR(hypothesis) #For every rule in the tree, see which ones have consequents that match my hypothesis matches = [] #iterate through every rule and collect the ones whose consequents match my hypothesis for rule in rules: #Fill in each consequent of the rule with the correct name of the antecendents for consequent in rule.consequent(): matchAttempt = match(consequent, hypothesis) #If we can match one of the consequents, we want to fill in the atecedents with the appropriate hypothesis if(matchAttempt != None and not rule in matches): for i, expression in enumerate(rule.antecedent()): rule.antecedent()[i] = populate(expression, matchAttempt) matches.append(rule) #At this point we have a list of the rules that match, and all of the antecendents are filled in with the variable names we can fill them in with treeNode = OR(hypothesis) for ruleMatch in matches: antecedent = ruleMatch.antecedent() if( isinstance(antecedent, AND)): node = AND() else: node = OR() for newHypothesis in antecedent: node.append(backchain_to_goal_tree(rules, newHypothesis)) treeNode.append(node) return simplify(treeNode)
def backchain_to_goal_tree(rules, hypothesis): hypothesis = OR(hypothesis) for rule in rules: var_list = match( rule.consequent()[0], hypothesis[0] ) #assume that rule.consequent() and hypothesis have exactly one string if var_list == None: continue else: if isinstance(rule.antecedent(), basestring): appendage = [ backchain_to_goal_tree( rules, populate(rule.antecedent(), var_list)) ] else: appendage = [ backchain_to_goal_tree(rules, populate(data, var_list)) for data in rule.antecedent() ] if isinstance(rule.antecedent(), AND): appendage = AND(appendage) else: #catch if class= basestring also, because it will be removed in simplify() appendage = OR(appendage) hypothesis.append(appendage) return simplify(hypothesis)
def backchain_to_goal_tree(rules, hypothesis): """ Takes a hypothesis (string) and a list of rules (list of IF objects), returning an AND/OR tree representing the backchain of possible statements we may need to test to determine if this hypothesis is reachable or not. This method should return an AND/OR tree, that is, an AND or OR object, whose constituents are the subgoals that need to be tested. The leaves of this tree should be strings (possibly with unbound variables), *not* AND or OR objects. Make sure to use simplify(...) to flatten trees where appropriate. """ hyp = OR([hypothesis]) for rule in rules: # for consequent in rule.consequent(): m = match(rule.consequent(), hypothesis) if m is not None: # good_consequent = populate(consequents, m) antecedents = rule.antecedent() if isinstance(antecedents, str): antecedents = [antecedents] antecedent = [ backchain_to_goal_tree(rules, populate(a, m)) for a in antecedents ] if isinstance(antecedents, OR): hyp.append(OR(antecedent)) else: hyp.append(AND(antecedent)) return simplify(hyp)
def backchain_to_goal_tree(rules, hypothesis,myLeaf = []): count = 0 for i in range(len(rules)): bindings = (match(rules[i].consequent()[0],hypothesis)) if bindings is not None: print 'type of bindings',bindings andLeaf = AND() orLeaf = OR() for x in range(len(rules[i].antecedent())): print 'in antecedent.....',rules[i].antecedent()[x] node = populate((rules[i].antecedent()[x]),bindings) if type(rules[i].antecedent()) == AND: andLeaf.append(populate((rules[i].antecedent()[x]),bindings)) myLeaf.append(simplify(andLeaf)) print 'andLeaf', andLeaf if type(rules[i].antecedent()) == OR: orLeaf.append(populate((rules[i].antecedent()[x]),bindings)) myLeaf.append(simplify(orLeaf)) print 'orLeaf',orLeaf disnode = backchain_to_goal_tree(rules,node) else: print 'hypothesis' #myLeaf.append(hypothesis) return simplify(myLeaf)
def backchain_to_goal_tree(rules, hypothesis): """ Takes a hypothesis (string) and a list of rules (list of IF objects), returning an AND/OR tree representing the backchain of possible statements we may need to test to determine if this hypothesis is reachable or not. This method should return an AND/OR tree, that is, an AND or OR object, whose constituents are the subgoals that need to be tested. The leaves of this tree should be strings (possibly with unbound variables), *not* AND or OR objects. Make sure to use simplify(...) to flatten trees where appropriate. """ tree = OR(hypothesis) for rule in rules: bounded = match(rule.consequent(), hypothesis) #check if rule can produce the hypothesis if bounded != None: new_antecedent = populate(rule.antecedent(), bounded) #populate the vars of the rule's antecdent #recurse on antecedent if type(new_antecedent) == str: tree.append(backchain_to_goal_tree(rules,new_antecedent)) else: for i,new_hypothesis in enumerate(new_antecedent): new_antecedent[i] = backchain_to_goal_tree(rules,new_hypothesis) tree.append(new_antecedent) return simplify(tree)
def backchain_to_goal_tree(rules, hypothesis): """ Takes a hypothesis (string) and a list of rules (list of IF objects), returning an AND/OR tree representing the backchain of possible statements we may need to test to determine if this hypothesis is reachable or not. This method should return an AND/OR tree, that is, an AND or OR object, whose constituents are the subgoals that need to be tested. The leaves of this tree should be strings (possibly with unbound variables), *not* AND or OR objects. Make sure to use simplify(...) to flatten trees where appropriate. """ tree = OR(hypothesis) if len(rules)==0: return hypothesis for rule in rules: if match(rule.consequent()[0], hypothesis) is not None: popRule = populate(rule.antecedent(), match(rule.consequent()[0], hypothesis)) if isinstance(popRule, (AND, OR)): for i in xrange(len(popRule)): popRule[i]=backchain_to_goal_tree(rules, popRule[i]) tree.append(popRule) else: new_tree=backchain_to_goal_tree(rules, popRule) tree.append(new_tree) return simplify(tree)
def backchain_to_goal_tree(rules, hypothesis): anyMatches = False results = OR(hypothesis) for rule in rules: for statement in rule.consequent(): matchOutput = match(statement, hypothesis) if matchOutput !=None: anyMatches = True populatedAnt = populate(rule.antecedent(), matchOutput) #populate antecedent with vocab if isinstance(populatedAnt,list): ands = AND() ors = OR() for statement in populatedAnt: #populated Ant is and / or if isinstance(populatedAnt,AND): ands.append(backchain_to_goal_tree(rules,statement)) elif isinstance(populatedAnt,OR): ors.append(backchain_to_goal_tree(rules,statement)) if len(ands)!=0: results.append(ands) elif len(ors)!=0: results.append(ors) else: results.append(backchain_to_goal_tree(rules,populatedAnt)) if anyMatches == False: results.append(OR(hypothesis)) return simplify(results)
def backchain_to_goal_tree(rules, hypothesis): """ Takes a hypothesis (string) and a list of rules (list of IF objects), returning an AND/OR tree representing the backchain of possible statements we may need to test to determine if this hypothesis is reachable or not. This method should return an AND/OR tree, that is, an AND or OR object, whose constituents are the subgoals that need to be tested. The leaves of this tree should be strings (possibly with unbound variables), *not* AND or OR objects. Make sure to use simplify(...) to flatten trees where appropriate. """ tree = OR(hypothesis) for rule in rules: match_res = match(rule.consequent(), hypothesis) if match_res is not None: or_node = OR() tree.append(or_node) nodes = populate(rule.antecedent(), match_res) if type(nodes) == str: nodes = [nodes] for i in range(len(nodes)): nodes[i] = backchain_to_goal_tree(rules, nodes[i]) or_node.append(nodes) tree = simplify(tree) return tree
def backchain_to_goal_tree(rules, hypothesis): # print ("backchain_to_goal_tree", rules, hypothesis) result = OR(hypothesis) for rule in rules: for then in rule.consequent(): m = match(then, hypothesis) if m == None: continue if isinstance(rule.antecedent(), AND): new_rule = AND([ backchain_to_goal_tree(rules, populate(pattern, m)) for pattern in rule.antecedent() ]) result.append(new_rule) elif isinstance(rule.antecedent(), OR): new_rule = OR([ backchain_to_goal_tree(rules, populate(pattern, m)) for pattern in rule.antecedent() ]) result.append(new_rule) elif isinstance(rule.antecedent(), str): new_rule = OR( backchain_to_goal_tree(rules, populate(rule.antecedent(), m))) result.extend(new_rule) else: print("backchain_to_goal_tree confusing antecedent", rule.antecedent) return None return simplify(result)
def backchain_to_goal_tree(rules, hypothesis): goal_tree = OR() goal_tree.append(hypothesis) # The hypothesis is the ultimate CSF if not rules: return list(goal_tree) # Bad base test? Not sure why the need to cast back to list for rule in rules: consequent = rule.consequent()[0] # should handle multiple? bindings = match(consequent, hypothesis) if bindings or bindings == {}: antecedent = rule.antecedent() if isinstance(antecedent, AND): branch = AND() for condition in antecedent: cond = populate(condition, bindings) branch.append(backchain_to_goal_tree(rules, cond)) goal_tree.append(branch) elif isinstance(antecedent, OR): branch = OR() for condition in antecedent: cond = populate(condition, bindings) branch.append(backchain_to_goal_tree(rules, cond)) goal_tree.append(branch) else: # leaf leaf = populate(antecedent, bindings) goal_tree.append(leaf) goal_tree.append(backchain_to_goal_tree(rules, leaf)) # new leaf may match older consequent, need to check again return simplify(goal_tree)
def backchain_to_goal_tree(rules, hypothesis): goal_tree = OR(hypothesis) for rule in rules: consequence_pattern = rule.consequent()[0] bindings = match(consequence_pattern,hypothesis) if bindings == None: #print 'no rule was found' continue else: if isinstance(rule.antecedent(),AND): subtree = AND() else: subtree = OR() if isinstance(rule.antecedent(),(OR,AND)): for antecedent in rule.antecedent(): new_hypo = populate(antecedent,bindings) subtree.append(backchain_to_goal_tree(rules,new_hypo)) goal_tree.append(subtree) else: new_hypo = populate(rule.antecedent(),bindings) subtree.append(backchain_to_goal_tree(rules,new_hypo)) goal_tree.append(subtree) return simplify(goal_tree)
def backchain_to_goal_tree(rules, hypothesis, myLeaf=[]): count = 0 for i in range(len(rules)): bindings = (match(rules[i].consequent()[0], hypothesis)) if bindings is not None: print 'type of bindings', bindings andLeaf = AND() orLeaf = OR() for x in range(len(rules[i].antecedent())): print 'in antecedent.....', rules[i].antecedent()[x] node = populate((rules[i].antecedent()[x]), bindings) if type(rules[i].antecedent()) == AND: andLeaf.append( populate((rules[i].antecedent()[x]), bindings)) myLeaf.append(simplify(andLeaf)) print 'andLeaf', andLeaf if type(rules[i].antecedent()) == OR: orLeaf.append( populate((rules[i].antecedent()[x]), bindings)) myLeaf.append(simplify(orLeaf)) print 'orLeaf', orLeaf disnode = backchain_to_goal_tree(rules, node) else: print 'hypothesis' #myLeaf.append(hypothesis) return simplify(myLeaf)
def backchain_to_goal_tree(rules, hypothesis): tree=OR(hypothesis) #print "hypothesis: "+str(hypothesis) matches=False for rule in rules: #print "rule: "+str(rule) cons=rule.consequent() ant=rule.antecedent() #print "cons: "+str(cons) for c in cons: #print "c:"+str(c) if match(c,hypothesis)!=None: matches=True if isinstance(ant, AND): subtree=AND() for a in ant: subtree.append(backchain_to_goal_tree(rules,populate(a, match(c,hypothesis)))) elif isinstance(ant, OR): subtree=OR() for a in ant: subtree.append(backchain_to_goal_tree(rules,populate(a,match(c,hypothesis)))) else: subtree=backchain_to_goal_tree(rules, populate(ant,match(c,hypothesis))) tree.append(subtree) if not(match): tree.append(hypothesis) return simplify(tree)
def backchain_to_goal_tree_rec(rules, hypothesis, protagonist): hy_li = hypothesis.split(' ') hy_li.pop(0) clean_hypothesis = ' '.join(hy_li) goaltree = OR() goaltree.append(protagonist + " " + clean_hypothesis) for rule in rules: clean_consequent = removeX(rule.consequent()) if clean_consequent == clean_hypothesis: antecedents = rule.antecedent() if isinstance(antecedents, list): subtree = [] if isinstance(antecedents, OR): subtree = OR() if isinstance(antecedents, AND): subtree = AND() for antecedent in antecedents: subtree.append( backchain_to_goal_tree_rec(rules, antecedent, protagonist)) goaltree.append(subtree) else: goaltree.append( backchain_to_goal_tree_rec(rules, antecedents, protagonist)) return goaltree
def backchain_to_goal_tree(rules, hypothesis): """ Takes a hypothesis (string) and a list of rules (list of IF objects), returning an AND/OR tree representing the backchain of possible statements we may need to test to determine if this hypothesis is reachable or not. This method should return an AND/OR tree, that is, an AND or OR object, whose constituents are the subgoals that need to be tested. The leaves of this tree should be strings (possibly with unbound variables), *not* AND or OR objects. Make sure to use simplify(...) to flatten trees where appropriate. """ goal_tree = OR(hypothesis) for rule in rules: bindings = match(rule.consequent(), hypothesis) if bindings != None: instantiated_ant = [] if isinstance(rule.antecedent(), str): bounded_ant = populate(rule.antecedent(), bindings) goal_tree.append(bounded_ant) goal_tree.append(backchain_to_goal_tree(rules, bounded_ant)) for ant in rule.antecedent(): instantiated_ant.append( backchain_to_goal_tree(rules, populate(ant, bindings))) if isinstance(rule.antecedent(), AND): goal_tree.append(AND(instantiated_ant)) if isinstance(rule.antecedent(), OR): goal_tree.append(OR(instantiated_ant)) return simplify(goal_tree)
def backchain_to_goal_tree(rules, hypothesis): root = OR(hypothesis) for rule in rules: for consequent in rule.consequent(): matchResult = match(consequent, hypothesis) if matchResult != None: antecedent = rule.antecedent() newHypothesis = AND() if isinstance(antecedent, AND) else OR() if isinstance(antecedent, str): antecedent = [antecedent] for part in antecedent: newHypothesis.append(backchain_to_goal_tree(rules, populate(part, matchResult))) root.append(newHypothesis) return simplify(root)
def myfunc(rule, rules, deneme, hypothesis): yedek = OR() for ante in rule.antecedent(): deger = myfunc2(rule, rules, populate(ante, deneme), deneme) #print(deger) if deger != OR() and deger != rule.antecedent(): yedek.append(deger) #print(yedek) #print(populate(ante,deneme)) #print(simplify(yedek)) if yedek == OR(): return OR() #return AND(yedek,populate(ante,deneme)) if type(rule.antecedent()) == OR: return OR(yedek, myfunc3(rule, deneme)) return AND(yedek, myfunc3(rule, deneme))
def backchain_to_goal_tree(rules, hypothesis): matches = OR() bindings = {} tree = OR() for rule in rules: consequent = rule.consequent()[0] if match(consequent, hypothesis): matches.append(rule) bindings = variables(consequent) if len(matches) < 1: return hypothesis else: for rule in matches: for exp in rule.antecedent(): n_hypothesis = populate(exp, bindings) tree.append(backchain_to_goal_tree(rules, n_hypothesis)) return simplify(tree)
def backchain_to_goal_tree(rules, hypothesis): tree = OR(hypothesis) for rule in rules: for c in rule.consequent(): bindings = match(c, hypothesis) if bindings is not None: populated_antecedent = populate(rule.antecedent(), bindings) if isinstance(populated_antecedent, str): populated_antecedent = OR(populated_antecedent) for i, hyp in enumerate(populated_antecedent): sub_tree = backchain_to_goal_tree(rules, hyp) populated_antecedent[i] = sub_tree tree.append(populated_antecedent) return simplify(tree)
def backchain_to_goal_tree(rules, hypothesis): goalTree = OR(hypothesis) for rule in rules: for consequent in rule.consequent(): bindings = match(consequent, hypothesis) if bindings != None: tp = AND() if isinstance(rule.antecedent(), AND) else OR() antecedents = rule.antecedent() if not isinstance(antecedents, list): antecedents = [antecedents] for antecedent in antecedents: tp.append( backchain_to_goal_tree(rules, populate(antecedent, bindings))) print tp goalTree.append(tp) return simplify(goalTree)
def backchain_to_goal_tree(rules, hypothesis): matching_rules = [] runningOR = OR() for rule in rules: match_result = match(rule._action[0], hypothesis) if match_result != None: runningOR.append(populate(rule._action[0], match_result)) conditional = rule._conditional runningCondition = AND() for condition in range(0, len(conditional)): condition2 = populate(conditional[condition], match_result) runningCondition.append(backchain_to_goal_tree(rules, condition2)) runningOR.append(runningCondition) if len(runningOR) != 0: return simplify(runningOR) else: return hypothesis
def backchain_to_goal_tree(rules, hypothesis): matching_rules = [] runningOR = OR() for rule in rules: match_result = match(rule._action[0], hypothesis) if match_result != None: runningOR.append(populate(rule._action[0], match_result)) conditional = rule._conditional runningCondition = AND() for condition in range(0, len(conditional)): condition2 = populate(conditional[condition], match_result) runningCondition.append( backchain_to_goal_tree(rules, condition2)) runningOR.append(runningCondition) if len(runningOR) != 0: return simplify(runningOR) else: return hypothesis
def backchain_to_goal_tree(rules, hypothesis): # check rules for matching consequents # i) no matches -> hypothesis is a leaf # ii) matches -> OR(antecedent) or_cond = OR() # always append the hypothesis or_cond.append(hypothesis) for rule in rules: bindings = match(rule.consequent()[0], hypothesis) if bindings: # append the goal tree from the antecedent ante = rule.antecedent() if isinstance(ante, RuleExpression): or_cond.append( expand_subtree(ante, bindings, rules) ) return simplify( or_cond )
def backchain_to_goal_tree(rules, hypothesis): matchedRules = [] orExpression = OR(hypothesis) for rule in rules: for expression in rule.consequent(): thisMatch = match(expression, hypothesis) if(not thisMatch is None): ruleExpression = orExpression antecedant = rule.antecedent() if(isinstance(antecedant, RuleExpression)): if(isinstance(antecedant, AND)): andExpression = AND() orExpression.append(andExpression) ruleExpression = andExpression for antecedantExpression in antecedant: ruleExpression.append(backchain_to_goal_tree(rules, populate(antecedantExpression, thisMatch))) else: orExpression.append(populate(backchain_to_goal_tree(rules, antecedant), thisMatch)) return simplify(orExpression)
def backchain_to_goal_tree(rules, hypothesis): i = 0 tree = OR() for rule in rules: #for ante in rule.antecedent(): #if i>=1 and i<len(rule.antecedent()): #birsey.append(ante) #i+=1 for cons in rule.consequent(): if match(cons, hypothesis) or hypothesis == cons: deneme = match(cons, hypothesis) #bakalim=(backchain_to_goal_tree,populate(rule.antecedent(),deneme),rules) #print(rule) tree.append( OR(hypothesis, myfunc(rule, rules, deneme, hypothesis))) if tree == OR(): return ['stuff'] antelist.clear() return simplify(tree)
def backchain_to_goal_tree(rules, hypothesis): goal_tree = OR(hypothesis) for rule in rules: for expr in rule.consequent(): bindings = match(expr, hypothesis) if bindings or bindings == {}: # we have a match antecedent = rule.antecedent() subtree = AND() if isinstance(antecedent, AND) else OR() if isinstance(antecedent, str): new_nodes = [populate(antecedent, bindings)] else: new_nodes = [populate(subexpr, bindings) for subexpr in antecedent] for new_node in new_nodes: subtree.append(backchain_to_goal_tree(rules, new_node)) goal_tree.append(subtree) return simplify(goal_tree)
def backchain_to_goal_tree(rules, hypothesis): result = OR(hypothesis) for rule in rules: b = [] hype = [] for con in rule.consequent(): if match(con, hypothesis) is not None: b.append(match(con, hypothesis)) for i in b: if i is not None and isinstance(rule.antecedent(), (AND, OR)): for j in rule.antecedent(): if populate(j, i) is not None: hype.append(populate(j, i)) elif i is not None: if populate(rule.antecedent(), i) is not None: hype.append(populate(rule.antecedent(), i)) if len(hype) > 0: if isinstance(rule.antecedent(), AND): result.append(AND()) for h in hype: result[-1].append(backchain_to_goal_tree(rules, h)) elif isinstance(rule.antecedent(), OR): result.append(OR()) for h in hype: result[-1].append(backchain_to_goal_tree(rules, h)) else: for h in hype: result.append(backchain_to_goal_tree(rules, h)) result=simplify(result) return result
def backchain_to_goal_tree(rules, hypothesis): # print 'START backchain_to_goal_tree', hypothesis goal_tree = OR() matching_rules = find_matching_rules(rules, hypothesis) #print "matching rules", matching_rules if len(matching_rules) > 0: goal_tree.append(hypothesis) for rule in matching_rules: consequent = rule.consequent() antecedent = rule.antecedent() for c in consequent: bindings = match(c, hypothesis) if bindings != None: #print "consequent:", c #print "antecedent:", antecedent #print "bindings:", bindings if isinstance(antecedent, (OR, AND)): for i in xrange(len(antecedent)): new_hypothesis = populate(antecedent[i], bindings) #print "new hypothesis", new_hypothesis antecedent[i] = backchain_to_goal_tree( rules, new_hypothesis) goal_tree.append(antecedent) else: new_hypothesis = populate(antecedent, bindings) goal_tree.append( backchain_to_goal_tree(rules, new_hypothesis)) goal_tree = simplify(goal_tree) else: goal_tree = hypothesis return goal_tree
def backchain_to_goal_tree(rules, hypothesis): length = len(rules) if length == 0: return hypothesis tree = OR() for element in rules: con = element.consequent() mat = match(con[0], hypothesis) if mat is not None and len(mat) >= 0: antec = element.antecedent() if isinstance(antec, list): sub = AND() if isinstance(antec, OR): sub = OR() for x in antec: new_tree = backchain_to_goal_tree(rules, populate(x, mat)) sub.append(new_tree) tree.append(sub) else: new_tree = backchain_to_goal_tree(rules, populate(antec, mat)) tree.append(AND(new_tree)) else: tree.append(hypothesis) new = simplify(tree) return new
def backchain_to_goal_tree(rules, hypothesis): goal_tree = OR(hypothesis) for rule in rules: consequent = rule.consequent()[0] matching = match(consequent, hypothesis) if matching or matching == {}: if isinstance(rule.antecedent(), AND): leaf_tree = AND() for antecedent in rule.antecedent(): if populate(antecedent, matching): leaf_tree.append( backchain_to_goal_tree( rules, populate(antecedent, matching))) goal_tree.append(leaf_tree) else: leaf_tree.append( backchain_to_goal_tree(rules, antecedent)) elif isinstance(rule.antecedent(), OR): leaf_tree = OR() for antecedent in rule.antecedent(): if populate(antecedent, matching): leaf_tree.append( backchain_to_goal_tree( rules, populate(antecedent, matching))) goal_tree.append(leaf_tree) else: leaf_tree.append( backchain_to_goal_tree(rules, antecedent)) else: goal_tree.append( backchain_to_goal_tree( rules, populate(rule.antecedent(), matching))) return simplify(goal_tree)
def backchain_to_goal_tree(rules, hypothesis): """ Takes a hypothesis (string) and a list of rules (list of IF objects), returning an AND/OR tree representing the backchain of possible statements we may need to test to determine if this hypothesis is reachable or not. This method should return an AND/OR tree, that is, an AND or OR object, whose constituents are the subgoals that need to be tested. The leaves of this tree should be strings (possibly with unbound variables), *not* AND or OR objects. Make sure to use simplify(...) to flatten trees where appropriate. """ goal_tree = OR() for rule in rules: var = match(rule.consequent(),hypothesis) if var != None: sub_hypothesis = populate(rule.antecedent(), var) if isinstance(sub_hypothesis, OR): sub_tree = [backchain_to_goal_tree(rules, antecedent) for antecedent in sub_hypothesis] goal_tree.append(OR(sub_tree)) elif isinstance(sub_hypothesis, AND): sub_tree = [backchain_to_goal_tree(rules, antecedent) for antecedent in sub_hypothesis] goal_tree.append(AND(sub_tree)) else: goal_tree.append(backchain_to_goal_tree(rules, sub_hypothesis)) return simplify(OR(hypothesis, goal_tree))
def backchain_to_goal_tree(rules, hypothesis): #print "Rules: ",rules print "H: ",hypothesis #if hypothesis=='zot': #print "Rules: ",rules #nodes=[rule.antecedent() for rule in rules if (match(rule.consequent()[0],hypothesis) or match=={})] #print nodes a={} nodes=[] for rule in rules: #print "Consequent: ",rule.consequent()[0] d=match(rule.consequent()[0],hypothesis) #print d if d or d=={}: #print "MATCHED!!" nodes.append(rule.antecedent()) #print rule.antecedent() #print nodes test_match=match(rule.consequent()[0],hypothesis) if test_match: a = dict(a.items()+test_match.items()) print a tree=OR(hypothesis) for node in nodes: print "type: ",type(node) if type(node) is OR or type(node) is AND: print "\n\nAppending list of nodes: ",[backchain_to_goal_tree(rules, populate(elem,a)) for elem in node] tree.append(type(node)([backchain_to_goal_tree(rules, populate(elem,a)) for elem in node])) else: print "\n\nAppending node: ",backchain_to_goal_tree(rules,populate(node,a)) tree.append(backchain_to_goal_tree(rules,populate(node,a))) print "\n\n#####TREE!!\n",simplify(tree) return simplify(tree)
def backchain_to_goal_tree(rules, hypothesis): goal = OR(hypothesis) backchain = partial(backchain_to_goal_tree, rules) for rule in rules: csq = rule.consequent() if isinstance(csq, str): csq = [csq] for clause in csq: binds = match(clause, hypothesis) if binds != None: ants = rule.antecedent() if isinstance(ants, str): ants = [ants] op = None if isinstance(ants, OR): op = OR else: op = AND goal.append(op([backchain(populate(ant, binds)) for ant in ants])) return simplify(goal)
def backchain_to_goal_tree(rules, hypothesis): ## raise NotImplementedError goal_tree = OR(hypothesis) for rule in rules: consequce = rule.consequent()[0] bindings = match(consequce, hypothesis) sub_tree = [] if bindings is not None and len(bindings) > 0: antecedent = rule.antecedent() for elem in antecedent: new_hypothesis = populate(elem, bindings) pop_elem = backchain_to_goal_tree(rules, new_hypothesis) sub_tree.append(simplify(pop_elem)) if isinstance(antecedent, AND): sub_tree = AND(sub_tree) elif isinstance(antecedent, OR): sub_tree = OR(sub_tree) if len(sub_tree) > 0: goal_tree.append(sub_tree) return goal_tree
def backchain_to_goal_tree(rules, hypothesis): all_consequents = [ rule.consequent()[index] for rule in rules for index in range(0, len(rule.consequent())) ] matched_rules = [ rule for rule in rules if match(rule.consequent()[0], hypothesis) != None ] chain = OR(hypothesis) for rule in matched_rules: bindings = get_bindings(rule.consequent(), hypothesis) template, antecedents = extract(rule.antecedent()) for antecedent in antecedents: if antecedent_is_not_consequent_of_any_rule( all_consequents, antecedent): template.append(populate(antecedent, bindings)) else: template.append( backchain_to_goal_tree(rules, populate(antecedent, bindings))) chain.append(template) return simplify(chain)
def backchain_to_goal_tree(rules, hypothesis): if not rules: return hypothesis tree = OR(hypothesis) for rule in rules: for consequent in rule.consequent(): matches = match(consequent, hypothesis) if matches == None: continue variables = {} for name, value in matches.items(): variables[name] = value antecedents = rule.antecedent() # If antecedents is a string, behave as it is a list with single item - unify antecedents handling if isinstance(antecedents, str): antecedents = [antecedents] # Determine type of antecedents if isinstance(rule.antecedent(), AND): statements = AND() else: statements = OR() # For each antecedent generate new possible subtree for antecedent in antecedents: new_hypothesis = populate(antecedent, variables) subtree = backchain_to_goal_tree(rules, new_hypothesis) statements.append(subtree) tree.append(simplify(statements)) return simplify(tree)
def backchain_to_goal_tree(rules, hypothesis): """ Takes a hypothesis (string) and a list of rules (list of IF objects), returning an AND/OR tree representing the backchain of possible statements we may need to test to determine if this hypothesis is reachable or not. This method should return an AND/OR tree, that is, an AND or OR object, whose constituents are the subgoals that need to be tested. The leaves of this tree should be strings (possibly with unbound variables), *not* AND or OR objects. Make sure to use simplify(...) to flatten trees where appropriate. """ print('---->', rules, '---->', hypothesis, len(rules)) if len(rules) == 0: return hypothesis tree = OR() for rule in rules: rule_consequent = rule.consequent() # Rule consequents always have just a single statement. rule_match = match(rule_consequent, hypothesis) # if rule_match, stupid mistake which has already been claimed in the website and said that 'match("foo", "foo") => {}' would be false if rule_match is not None: rule_antecedent = rule.antecedent() if isinstance(rule_antecedent, list): sub_tree = AND() if isinstance(rule_antecedent, OR): sub_tree = OR() for sub in rule_antecedent: new_tree = backchain_to_goal_tree( rules, populate(sub, rule_match)) sub_tree.append(new_tree) tree.append(sub_tree) else: new_tree = backchain_to_goal_tree( rules, populate(rule_antecedent, rule_match)) tree.append(AND(new_tree)) else: tree.append(hypothesis) result = simplify(tree) return result
def backchain_to_goal_tree(rules, hypothesis): if len(rules) == 0: return hypothesis # initilialise a new node which will contain all of the matching consequences goal_tree = OR() # try to match the hypothesis to a THEN statment in the rules for i in range(len(rules)): # get the other potential matching leaf rule = rules[i] # check if there is a match matching = match(rule.consequent()[0], hypothesis) # in not none you have found a match if matching != None: # get the consequent and the antecedent cns = rule.consequent()[0] ant = rule.antecedent() if isinstance(ant, list): sub = AND() if isinstance(ant, OR): sub = OR() for statment in ant: # print(statment) # now recursivly call backchain on the ants statments new_node = backchain_to_goal_tree( rules, populate(statment, matching)) sub.append(new_node) # sub.append(ant) goal_tree.append(sub) else: goal_tree.append( backchain_to_goal_tree(rules, populate(ant, matching))) else: goal_tree.append(hypothesis) return simplify(goal_tree)
def myfunc2(rule, rules, hypothesis, deneme): yedek = OR() for rule in rules: for cons in rule.consequent(): #print(cons) if match(cons, hypothesis): deneme = match(cons, hypothesis) #print(rule.antecedent()) antelist.append(hypothesis) yedek.append(hypothesis) gelendeger = myfunc(rule, rules, deneme, hypothesis) if gelendeger != OR(): yedek.append(gelendeger) else: yedek.append(populate(rule.antecedent(), deneme)) #print(simplify(yedek)) return yedek
def backchain_to_goal_tree(rules, hypothesis): unbound = [(rule.antecedent(), match(rule.consequent()[0], hypothesis)) for rule in rules if not match(rule.consequent()[0], hypothesis) is None] bound = OR(hypothesis) for (ante, binding) in unbound: if type(ante) is AND: node_list = [populate(exp, binding) for exp in ante] bound.append( AND([ backchain_to_goal_tree(rules, node) for node in node_list ])) elif type(ante) is OR: node_list = [populate(exp, binding) for exp in ante] bound.append( OR([backchain_to_goal_tree(rules, node) for node in node_list])) else: node = populate(ante, binding) bound.append(backchain_to_goal_tree(rules, node)) return simplify(bound)