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): ors = [hypothesis] for rule in rules: consequents = rule.consequent() for consequent in consequents: matched_vars = match(consequent, hypothesis) # matched_vars match if matched_vars or consequent == hypothesis: antecedent = rule.antecedent() if isinstance(antecedent, str): populated = populate(antecedent, matched_vars) ors.append(populated) ors.append(backchain_to_goal_tree(rules, populated)) else: ante_rules = [ populate(rule, matched_vars) for rule in antecedent ] ante_res = [ backchain_to_goal_tree(rules, ante_rule) for ante_rule in ante_rules ] if isinstance(antecedent, AND): ors.append(AND(ante_res)) elif isinstance(antecedent, OR): ors.append(OR(ante_res)) return simplify(OR(ors))
def backchain_to_goal_tree(rules, hypothesis): # find rules that produces this hypothesis rules_con = [hypothesis] for rule in rules: for con in rule.consequent(): bindings = match(con, hypothesis) if (bindings != None): # this rule can result in the hypo ant = rule.antecedent() if (isinstance(ant, AND)): rules_con.append( AND([ backchain_to_goal_tree(rules, populate(branch, bindings)) for branch in ant ])) elif (isinstance(ant, OR)): rules_con.append( OR([ backchain_to_goal_tree(rules, populate(branch, bindings)) for branch in ant ])) else: rules_con.append( backchain_to_goal_tree(rules, populate(ant, bindings))) return simplify(OR(rules_con))
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): # 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): ret = hypothesis for rule in rules: consequent = rule.consequent() for conse in consequent: bindings = match(conse, hypothesis) if bindings != None: antecedent = rule.antecedent() if is_leaf_condition(antecedent): condition = antecedent.__class__ tmp = [] for ante in antecedent: new_hypothesis = populate(ante, bindings) ans = backchain_to_goal_tree(rules, new_hypothesis) tmp.append(ans) ret = OR(ret, condition(tmp)) else: new_hypothesis = populate(antecedent, bindings) tmp = backchain_to_goal_tree(rules, new_hypothesis) ret = OR(ret, tmp) return simplify(ret)
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): """ 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. """ matched = list([hypothesis]) for rule in rules: bound_conseq = match(rule.consequent(), hypothesis) if bound_conseq is not None: new_antes = list() if isinstance(rule.antecedent(), str): bound_ante = populate(rule.antecedent(), bound_conseq) matched.append(bound_ante) matched.append(backchain_to_goal_tree(rules, bound_ante)) for ant in rule.antecedent(): new_antes.append( backchain_to_goal_tree(rules, populate(ant, bound_conseq))) if isinstance(rule.antecedent(), AND): matched.append(AND(new_antes)) if isinstance(rule.antecedent(), OR): matched.append(OR(new_antes)) return simplify(OR(matched))
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. """ #creating the results of our hypothesis results = [hypothesis] #looping through all the rules (necessary for each new hypothesis under recursion) for rule in rules: #taking the binder variable binder = match(rule.consequent(), hypothesis) #seeing if there is actually a matching statement if binder or rule.consequent() == hypothesis: #collecting all the antecedents to a rule antecedents = rule.antecedent() #special case if there is only 1 antecedent if isinstance(antecedents, str): #resetting our hypothesis so we can recursively go #through the one hypothesis hypothesis = populate(antecedents, binder) #have to append the hypothesis itself results.append(hypothesis) #recursively go through rules again with new hypothesis results.append(backchain_to_goal_tree(rules, hypothesis)) else: #if the antecedent has more AND/OR statements (more depth) hypotheses = [ populate(antecedent, binder) for antecedent in antecedents ] #recursive results for each antecent(which became a new #hypothesis) sub_results = [ backchain_to_goal_tree(rules, hypothesis) for hypothesis in hypotheses ] #binding the sub_results correctly based on how the #antecedents were stored if isinstance(antecedents, AND): results.append(AND(sub_results)) elif isinstance(antecedents, OR): results.append(OR(sub_results)) #returning simplified version as we go return simplify(OR(results))
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(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): goal_tree = [hypothesis] for rule in rules: for consequent in rule.consequent(): # Extend from python list bound_variables = match(consequent, hypothesis) if bound_variables is not None: # We have matched expressions antecedent_list = rule.antecedent() if isinstance(antecedent_list, RuleExpression): # Complex expression if isinstance(antecedent_list, AND): inner_goal_tree = AND([ backchain_to_goal_tree( rules, populate(expr, bound_variables)) for expr in antecedent_list ]) elif isinstance(antecedent_list, OR): inner_goal_tree = OR([ backchain_to_goal_tree( rules, populate(expr, bound_variables)) for expr in antecedent_list ]) goal_tree.append(inner_goal_tree) else: # just a string, which is a single leaf node new_hypothesis = populate(antecedent_list, bound_variables) goal_tree.append( OR(backchain_to_goal_tree(rules, new_hypothesis))) return simplify(OR(goal_tree))
def backchain_to_goal_tree(rules, hypothesis): tree = [hypothesis] for rule in rules: cons = rule.consequent() antec = rule.antecedent() #Busco "matches" isInConsequent = False for pattern in cons: dictMatch = match(pattern,hypothesis) if(dictMatch != None): isInConsequent = True #print "Match!" #print rule break if(isInConsequent): listaTemp = [] if(not isinstance(antec,list)): #Es una expresion simple expP = populate(antec, dictMatch) expP = backchain_to_goal_tree(rules, expP) tree.append(expP) else: for exp in antec: expP = populate(exp,dictMatch) expP = backchain_to_goal_tree(rules,expP) listaTemp.append(expP) if(isinstance(antec,AND)): tree.append(AND(listaTemp)) elif(isinstance(antec,OR)): tree.append(OR(listaTemp)) return simplify(OR(tree))
def backchain_to_goal_tree(rules, hypothesis): """ LHG Code from 6.034, modified for the ADE system. 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. """ top_level = [hypothesis] for rule in rules: matching = match(rule.consequent(), hypothesis) if matching is not None: tree = [] next = populate(rule.antecedent(), matching) ant_stuff = type(rule.antecedent()) if ant_stuff is str: # leaf tree.append(backchain_to_goal_tree(rules, next)) else: for hyp in next: tree.append(backchain_to_goal_tree(rules, hyp)) if ant_stuff == OR: top_level.append(OR(tree)) else: top_level.append(AND(tree)) return simplify(OR(top_level))
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): 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): result = [] for rule in rules: matched = match(rule.consequent()[0], hypothesis) if matched != None: antecedent = rule.antecedent() result.append(iterate_node(rules, antecedent, matched)) if len(result) > 0: return simplify(OR(hypothesis, OR(result))) else: return 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. """ toReturnTrees = [hypothesis] matches = False for rule in rules: for consequent in rule.consequent(): variables = match(consequent, hypothesis) if variables == None: continue matches = True # the thing you have to prove is true, # in order to prove your hypothesis is true antecedent = rule.antecedent( ) #populate(rule.antecedent(), variables) # the subtree you will return tree = None if isinstance(antecedent, str): tree = backchain_to_goal_tree(rules, populate(antecedent, variables)) elif isinstance(antecedent, AND): tree = AND([ backchain_to_goal_tree(rules, populate(clause, variables)) for clause in antecedent ]) elif isinstance(antecedent, OR): tree = OR([ backchain_to_goal_tree(rules, populate(clause, variables)) for clause in antecedent ]) tree = simplify(tree) toReturnTrees.append(tree) if not matches: return hypothesis return simplify(simplify(OR([toReturnTrees])))
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): """ 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): 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 backchain_to_goal_tree(rules, hypothesis): """ #Try 3 tree = [hypothesis] for rule in rules: for exp in rule.consequent(): matching = match(exp, hypothesis) if matching !=None: antecedent = rule.antecedent() if type(antecedent) is str: newHyp = populate(antecedent, matching) tree.append(backchain_to_goal_tree(rules, newHyp)) tree.append(newHyp) else: statements = [populate(exp, matching) for exp in antecedent] newTree = [] for statement in statements: newTree.append(backchain_to_goal_tree(rules, statement)) if type(antecedent) == type(OR()): tree.append(OR(newTree)) else: tree.append(AND(newTree)) return simplify(OR(tree)) """ #Try 2 tree = [hypothesis] for rule in rules: for exp in rule.consequent(): matching = match(exp, hypothesis) if matching != None: filledAnts = populate(rule.antecedent(), matching) if type(filledAnts) == type(AND()): andState = AND([ backchain_to_goal_tree(rules, state) for state in filledAnts ]) tree.append(andState) elif type(filledAnts) == type(OR()): orState = OR([ backchain_to_goal_tree(rules, state) for state in filledAnts ]) tree.append(orState) else: tree.append(backchain_to_goal_tree(rules, filledAnts)) return simplify(OR(tree))
def transform(goal_tree): if isinstance(goal_tree, AND): return AND(map(lambda g: transform(g), goal_tree)) elif isinstance(goal_tree, OR): return OR(map(lambda g: transform(g), goal_tree)) else: return backchain_to_goal_tree(rules, populate(goal_tree, substitutions))
def create_statement(statements, rule): if isinstance(rule, AND): return AND(statements) elif isinstance(rule, OR): return OR(statements)
def backchain_to_goal_tree(rules, hypothesis): hows = [] for rule in rules: if isinstance(rule.consequent(), basestring): cons = [rule.consequent()] else: cons = rule.consequent() for c in rule.consequent(): m = match(c, hypothesis) if m is not None: instantiated_candidate = populate(c, m) hows.append(instantiated_candidate) antecedents_hows = [] if isinstance(rule.antecedent(), basestring): ants = [rule.antecedent()] else: ants = rule.antecedent() for ant in ants: p_ant = populate(ant, m) ant_hows = backchain_to_goal_tree(rules, p_ant) antecedents_hows.append(ant_hows) if isinstance(rule.antecedent(), basestring) or isinstance(rule.antecedent(), OR) : for ant_hows in antecedents_hows: hows.append(ant_hows) elif isinstance(rule.antecedent(), AND): hows.append(AND(*antecedents_hows)) else: raise ValueError, "something is wront with this antecedent: %s" % rule.antecedent() if not hows: return hypothesis else: return simplify(OR(hows))
def backchain_to_goal_tree(rules, hypothesis): new_hyp_list = [] goaltree = [] for rule in rules: for word in rule.consequent(): if match(rule.consequent()[0], hypothesis) != None: new_hyp = populate(rule.antecedent(), match(rule.consequent()[0], hypothesis)) new_hyp_list += [new_hyp] goaltree += [hypothesis] for new_hyp in new_hyp_list: goaltree += [new_hyp] goaltree = OR(goaltree) if len(goaltree) != 0: for i in range(1, len(goaltree)): if isinstance(goaltree[i], (list, tuple)): for j in range(0, len(goaltree[i])): goaltree[i][j] = simplify( backchain_to_goal_tree(rules, goaltree[i][j])) else: goaltree[i] = simplify( backchain_to_goal_tree(rules, goaltree[i])) goaltree = simplify(goaltree) return goaltree
def backchain_to_goal_tree(rules, hypothesis): or_list = [] for rule in rules: match_bindings = match(rule.consequent()[0], hypothesis) if match_bindings is not None: ant = populate(rule.antecedent(), match_bindings) if isinstance(ant, str): or_list.append(backchain_to_goal_tree(rules, ant)) elif isinstance(ant, AND): or_list.append( AND([backchain_to_goal_tree(rules, a) for a in ant])) elif isinstance(ant, OR): or_list.append( OR([backchain_to_goal_tree(rules, a) for a in ant])) else: print "ERROR:", ant, "is not str, AND, or OR" return simplify(OR([hypothesis] + or_list))
def iterate_node(rules, node, mapping): if isinstance(node, str): leaf = populate(node, mapping) return backchain_to_goal_tree(rules, leaf) elif isinstance(node, OR): return(OR([iterate_node(rules, exp, mapping) for exp in node])) elif isinstance(node, AND): return(AND([iterate_node(rules, exp, mapping) for exp in node]))
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): 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 find_ante(rules, hypothesis): antecedents = [hypothesis] for rule in rules: result = match(rule.consequent(), hypothesis) if result != None: ante = populate(rule.antecedent(), result) if isinstance(ante, AND): antecedents.append( simplify(AND([find_ante(rules, cond) for cond in ante]))) elif isinstance(ante, OR): antecedents.append( simplify(OR([find_ante(rules, cond) for cond in ante]))) else: antecedents.append(find_ante(rules, ante)) return simplify(OR(antecedents))
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 ('HYPOTHESIS: ', hypothesis) tree = [hypothesis] for rule in rules: consequent = rule.consequent() bindings = match(consequent, hypothesis) #print ('BINDINGS: ', bindings) #found a matching rule if bindings != None: antecedent = rule.antecedent() #if the antecedent is a statement, add it to the tree and recurse on it as the new hypothesis if isinstance(antecedent, str): new_hypothesis = populate(antecedent, bindings) tree.append(new_hypothesis) tree.append(backchain_to_goal_tree(rules, new_hypothesis)) #if not, go through each statement in antecedent, and recurse on them, build their subtree and add to the tree else: statements = [ populate(statement, bindings) for statement in antecedent ] subtree = [] for statement in statements: subtree.append(backchain_to_goal_tree(rules, statement)) #print ('SUBTREE: ', subtree) #for an AND antecedent if isinstance(antecedent, AND): tree.append(AND(subtree)) #for an OR antecedent else: tree.append(OR(subtree)) #print ('TREE: ', tree) return simplify(OR(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. """ 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): 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): 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): # 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): 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): #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): 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)