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):
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):
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, 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 = 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 myfunc3(rule, deneme):
eleman = AND()
for liste in populate(rule.antecedent(), deneme):
if not liste in antelist:
antelist.append(liste)
eleman.append(liste)
return eleman
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):
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):
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):
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.
"""
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):
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):
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):
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 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):
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):
output = OR(hypothesis)
matches = [
populate(r.antecedent(), match(r.consequent()[0], hypothesis))
for r in rules if matcher(r, hypothesis)
]
if len(matches) > 0:
for m in matches:
if isinstance(m, AND):
to_append = AND()
else:
to_append = OR()
if not isinstance(m, (AND, OR)):
m = AND(m)
for a in m:
child_append = OR(a)
child_append.append(backchain_to_goal_tree(rules, a))
to_append.append(child_append)
output.append(to_append)
else:
output.append(OR())
return simplify(output)
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):
goal_tree = OR(hypothesis)
consequent_match_list = []
# check through each rule
for rule in rules:
# if any consequent matches append rule
# for consequent in THEN('(?x) is a penguin', '(?x) is a zebra') -> '(?x) is a penguin'
for consequent in rule.consequent():
# match('(?x) is a penguin', 'opus is a penguin') -> {x:'opus'}
matched_variable = match(consequent, hypothesis)
# if the consequent matches the hypothesis
if not matched_variable == None:
# populate('(?x) is a penguin', {x: opus}) -> 'opus is a penguin'
# if the consequent really does match the hypothesis
consequent_matched = populate(consequent, matched_variable)
if consequent_matched == hypothesis:
# store the appropriate matched consequent, variable, and associated antecedents from the rule in a list
variables = match(consequent, hypothesis)
# append.(['(?x) is a penguin', {x: opus}, AND('(?x) is a bird', '(?x) does not fly')])
# consequent_match_list.append([consequent, variables, rule.antecedent()])
# go through each antecedent (or just the one if it is one)
antecedents = rule.antecedent()
# only one antecedent
if isinstance(antecedents, str):
if type(rule.antecedent()) is AND:
and_a = AND()
# associate antecedent with variable to form new hypothesis
# populate('(?x) is a bird', {x: 'opus'}) -> 'opus is a bird'
antecedent_matched = populate(
antecedents, variables)
# fill in goal tree AND() part with 'opus is a bird'
# now check if 'opus is a bird' as a new hypothesis generates antecedents and recursively act on
and_a.append(
backchain_to_goal_tree(rules,
antecedent_matched))
goal_tree.append(and_a)
else:
# associate antecedent with variable to form new hypothesis
# populate('(?x) is a bird', {x: 'opus'}) -> 'opus is a bird'
antecedent_matched = populate(
antecedents, variables)
# fill in goal tree AND() part with 'opus is a bird'
# now check if 'opus is a bird' as a new hypothesis generates antecedents and recursively act on
goal_tree.append(
backchain_to_goal_tree(rules,
antecedent_matched))
# multiple antecedents
else:
if type(rule.antecedent()) is AND:
and_a = AND()
for antecedent in rule.antecedent():
# associate antecedent with variable to form new hypothesis
# populate('(?x) is a bird', {x: 'opus'}) -> 'opus is a bird'
antecedent_matched = populate(
antecedent, variables)
# fill in goal tree AND() part with 'opus is a bird'
# now check if 'opus is a bird' as a new hypothesis generates antecedents and recursively act on
and_a.append(
backchain_to_goal_tree(
rules, antecedent_matched))
goal_tree.append(and_a)
else:
for antecedent in rule.antecedent():
# associate antecedent with variable to form new hypothesis
# populate('(?x) is a bird', {x: 'opus'}) -> 'opus is a bird'
antecedent_matched = populate(
antecedent, variables)
# fill in goal tree AND() part with 'opus is a bird'
# now check if 'opus is a bird' as a new hypothesis generates antecedents and recursively act on
goal_tree.append(
backchain_to_goal_tree(
rules, antecedent_matched))
return simplify(goal_tree)
