def main():
KB = KnowledgeBase([], [])
_, fact1 = read.parse_input("fact: (hero A)")
_, fact2 = read.parse_input("fact: (person A)")
_, rule1 = read.parse_input(
"rule: ((hero ?x) (person ?x)) -> (goodman ?x)")
_, rule2 = read.parse_input(
"rule: ((goodman ?x) (wenttoschool ?x)) -> (doctor ?x)")
_, fact3 = read.parse_input("fact: (wenttoschool A)")
_, ask1 = read.parse_input("fact: (goodman A)")
_, ask2 = read.parse_input("fact: (doctor A)")
_, ask3 = read.parse_input("rule: ((person A)) -> (goodman A)")
KB.kb_assert(fact1)
KB.kb_assert(fact2)
KB.kb_assert(rule1)
KB.kb_assert(rule2)
KB.kb_assert(fact3)
answer1 = KB.kb_ask(ask1)
answer2 = KB.kb_ask(ask2)
answer3 = Rule(ask3) in KB.rules
KB.kb_retract(fact1)
answer4 = KB.kb_ask(ask1)
answer5 = KB.kb_ask(ask2)
answer6 = Rule(ask3) in KB.rules
print KB
if answer1 and answer2 and answer3 and not answer4 and not answer5 and not answer6:
print "pass test4"
exit(0)
else:
print "fail test4"
exit(1)
def main():
KB = KnowledgeBase([], [])
_, fact1 = read.parse_input("fact: (hero A)")
_, fact2 = read.parse_input("fact: (person A)")
_, rule1 = read.parse_input("rule: ((hero ?x) (person ?x)) -> (goodman ?x)")
_, rule2 = read.parse_input("rule: ((goodman ?x) (wenttoschool ?x)) -> (doctor ?x)")
_, fact3 = read.parse_input("fact: (wenttoschool A)")
_, fact4 = read.parse_input("fact: (goodman A)")
_, ask1 = read.parse_input("fact: (goodman A)")
_, ask2 = read.parse_input("fact: (doctor A)")
_, ask3 = read.parse_input("rule: ((person A)) -> (goodman A)")
KB.kb_assert(fact1)
#print KB
KB.kb_assert(fact2)
#print KB
KB.kb_assert(fact4)
#print KB
KB.kb_assert(rule1)
#print KB
KB.kb_assert(rule2)
KB.kb_assert(fact3)
print KB
answer1 = KB.kb_ask(ask1)
answer2 = KB.kb_ask(ask2)
KB.kb_retract(fact1)
answer3 = not Rule(ask3) in KB.rules
print KB
answer4 = KB.kb_ask(ask1)
answer5 = KB.kb_ask(ask2)
KB2 = KnowledgeBase([], [])
_, fact21 = read.parse_input("fact: (relaa A)")
_, fact22 = read.parse_input("fact: (relab A)")
_, rule21 = read.parse_input("rule: ((relaa ?x)) -> (good ?x)")
_, rule22 = read.parse_input("rule: ((relab ?x)) -> (good ?x)")
_, ask21 = read.parse_input("fact: (good ?x)")
KB2.kb_assert(fact21)
KB2.kb_assert(fact22)
KB2.kb_assert(rule21)
KB2.kb_assert(rule22)
#print KB2
answer6 = KB2.kb_ask(ask21)
KB2.kb_retract(fact21)
answer7 = KB2.kb_ask(ask21)
answer8 = not KB2.kb_ask(fact21)
#print KB2
#print str(answer2)
if not answer4:
print "!!!!!!!!!!! test5"
if answer1 and answer2 and answer3 and answer4 and answer5 and answer6 and answer7 and answer8:
print "pass test5"
exit(0)
else:
print "fail test5"
exit(1)
class CustomTests2(unittest.TestCase):
def setUp(self):
# Assert starter facts
file = 'statements_kb5.txt'
self.data = read.read_tokenize(file)
data = read.read_tokenize(file)
self.KB = KnowledgeBase([], [])
for item in data:
if isinstance(item, Fact) or isinstance(item, Rule):
self.KB.kb_assert(item)
def test6(self):
# makes sure retract does not retract supported fact
ask1 = read.parse_input("fact: (grandparent A ?X)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertEqual(str(answer[0]), "?X : C")
# self.assertEqual(str(answer[1]), "?X : chen")
r1 = read.parse_input("fact: (parent B C)")
print(' Retracting', r1)
self.KB.kb_retract(r1)
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertEqual(str(answer[0]), "?X : C")
r1 = read.parse_input("fact: (parent A D)")
print(' Retracting', r1)
self.KB.kb_retract(r1)
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
print(str(len(answer)))
self.assertEqual(len(answer), 0)
def main():
KB = KnowledgeBase([], [])
_, fact1 = read.parse_input("fact: (rela A B C D E F)")
_, fact2 = read.parse_input("fact: (relb D E F G H I)")
_, fact3 = read.parse_input("fact: (reld G H I)")
_, rule1 = read.parse_input(
"rule: ((rela ?a ?b ?c ?d ?e ?f) (relb ?d ?e ?f ?g ?h ?i)) -> (relc ?a ?b ?c ?g ?h ?i)"
)
_, rule2 = read.parse_input(
"rule: ((relc ?a ?b ?c ?g ?h ?i) (reld ?g ?h ?i)) -> (rele ?a ?b ?c)")
_, ask1 = read.parse_input("fact: (rele A B C)")
KB.kb_assert(fact1)
KB.kb_assert(fact2)
KB.kb_assert(fact3)
KB.kb_assert(rule1)
KB.kb_assert(rule2)
answer1 = KB.kb_ask(ask1)
KB.kb_retract(fact1)
answer2 = KB.kb_ask(ask1)
if answer1 and not answer2:
print "pass test9"
exit(0)
else:
print "fail test9"
exit(1)
class KBTest(unittest.TestCase):
def setUp(self):
# Assert starter facts
file = 'statements_kb4.txt'
self.data = read.read_tokenize(file)
data = read.read_tokenize(file)
self.KB = KnowledgeBase([], [])
for item in data:
if isinstance(item, Fact) or isinstance(item, Rule):
self.KB.kb_assert(item)
def test3(self):
r1 = read.parse_input("fact: (motherof ada bing)")
print(' Retracting', r1)
self.KB.kb_retract(r1)
ask1 = read.parse_input("fact: (grandmotherof ada ?X)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertEqual(str(answer[0]), "?X : felix")
def main():
KB = KnowledgeBase([], [])
_, fact1 = read.parse_input("fact: (hero A)")
_, fact2 = read.parse_input("fact: (person A)")
_, fact3 = read.parse_input("fact: (goodman A)")
_, rule1 = read.parse_input(
"rule: ((hero ?x) (person ?x)) -> (goodman ?x)")
KB.kb_assert(fact1)
KB.kb_assert(fact2)
KB.kb_assert(fact3)
KB.kb_assert(rule1)
answer1 = KB.facts[KB.facts.index(Fact(fact3))].asserted
KB.kb_retract(fact3)
answer2 = KB.facts[KB.facts.index(Fact(fact3))].asserted
if answer1 and not answer2:
print "pass test10"
exit(0)
else:
print "fail test10"
exit(1)
class KBTest(unittest.TestCase):
def setUp(self):
# Assert starter facts
file = 'statements_kb6.txt'
self.data = read.read_tokenize(file)
data = read.read_tokenize(file)
self.KB = KnowledgeBase([], [])
for item in data:
if isinstance(item, Fact) or isinstance(item, Rule):
self.KB.kb_assert(item)
def test1(self):
print("--------------------TEST ONE-----------------------")
# makes sure retract does not retract supported fact
# student test from piazza
ask1 = read.parse_input("fact: (grandparent A ?X)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertEqual(str(answer[0]), "?X : C")
r1 = read.parse_input("fact: (parent B C)")
print(' Retracting', r1)
self.KB.kb_retract(r1)
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertEqual(str(answer[0]), "?X : C")
r1 = read.parse_input("fact: (parent A D)")
print(' Retracting', r1)
self.KB.kb_retract(r1)
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
print(str(len(answer)))
self.assertEqual(0, len(answer))
class KBTest(unittest.TestCase):
def setUp(self):
# Assert starter facts
file = 'statements_kb4.txt'
self.data = read.read_tokenize(file)
data = read.read_tokenize(file)
self.KB = KnowledgeBase([], [])
for item in data:
if isinstance(item, Fact) or isinstance(item, Rule):
self.KB.kb_assert(item)
# def test1(self):
# # Did the student code contain syntax errors, AttributeError, etc.
# ask1 = read.parse_input("fact: (motherof ada ?X)")
# print(' Asking if', ask1)
# answer = self.KB.kb_ask(ask1)
# self.assertEqual(str(answer[0]), "?X : bing")
#
# def test2(self):
# # Can fc_infer actually infer
# ask1 = read.parse_input("fact: (grandmotherof ada ?X)")
# print(' Asking if', ask1)
# answer = self.KB.kb_ask(ask1)
# self.assertEqual(str(answer[0]), "?X : felix")
# self.assertEqual(str(answer[1]), "?X : chen")
def test3(self):
# Does retract actually retract things
r1 = read.parse_input("fact: (motherof ada bing)")
print(' Retracting', r1)
self.KB.kb_retract(r1)
ask1 = read.parse_input("fact: (grandmotherof ada ?X)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertEqual(len(answer), 1)
self.assertEqual(str(answer[0]), "?X : felix")
class KBTest(unittest.TestCase):
def setUp(self):
# Assert starter facts
file = 'statements_kb3.txt'
self.data = read.read_tokenize(file)
data = read.read_tokenize(file)
self.KB = KnowledgeBase([], [])
for item in data:
if isinstance(item, Fact) or isinstance(item, Rule):
self.KB.kb_assert(item)
def test1(self):
ask1 = read.parse_input("fact: (hero ?y)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertEqual(str(answer[0]), "?Y : a")
def test2(self):
ask1 = read.parse_input("fact: (person ?y)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertEqual(str(answer[0]), "?Y : a")
def test3(self):
ask1 = read.parse_input("fact: (goodman ?y)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertEqual(str(answer[0]), "?Y : a")
def test4(self):
r1 = read.parse_input("fact: (goodman a)")
print(' Retracting', r1)
self.KB.kb_retract(r1)
ask1 = read.parse_input("fact: (goodman ?y)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertEqual(str(answer[0]), "?Y : a")
def test5(self):
r1 = read.parse_input("fact: (hero a)")
print(' Retracting', r1)
self.KB.kb_retract(r1)
ask1 = read.parse_input("fact: (goodman ?y)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertEqual(answer, [])
def test6(self):
r1 = read.parse_input("fact: (person a)")
print(' Retracting', r1)
self.KB.kb_retract(r1)
ask1 = read.parse_input("fact: (goodman ?y)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertEqual(answer, [])
class CustomTests4(unittest.TestCase):
def setUp(self):
# Assert starter facts
file = 'statements_kb6.txt'
self.data = read.read_tokenize(file)
data = read.read_tokenize(file)
self.KB = KnowledgeBase([], [])
for item in data:
if isinstance(item, Fact) or isinstance(item, Rule):
self.KB.kb_assert(item)
def test6(self):
"""this student generated test ensures retract only removes facts and rules that are supported by
1 or less fact-rule pairs
"""
r1 = read.parse_input("fact: (dresslike profHammond TonyStark)")
print(' Retracting', r1)
self.KB.kb_retract(r1)
ask1 = read.parse_input("fact: (isliterally ?X TonyStark)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertEqual(str(answer[0]), "?X : profHammond")
ask2 = read.parse_input("fact: (resembles profHammond ?Y)")
print(' Asking if', ask2)
answer = self.KB.kb_ask(ask2)
self.assertFalse(answer)
def test7(self):
"""this student generated test ensures retracting the 2nd fact in the lhs of a rule
successfully retracts the final inferred fact but re-assertion re-infers the fact
"""
r1 = read.parse_input("fact: (lookslike profHammond TonyStark)")
print(' Retracting', r1)
self.KB.kb_retract(r1)
ask1 = read.parse_input("fact: (resembles profHammond ?Y)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertFalse(answer)
a1 = read.parse_input("fact: (lookslike profHammond TonyStark)")
print(' Reasserting', a1)
self.KB.kb_assert(a1)
ask2 = read.parse_input("fact: (resembles profHammond ?Y)")
print(' Asking if', ask2)
answer = self.KB.kb_ask(ask2)
self.assertEqual(str(answer[0]), "?Y : TonyStark")
def test8(self):
"""this student generated test ensures retracting a fact that supports inferences 2 links away
also retracts all facts down that chain
"""
r1 = read.parse_input("fact: (techgenius profHammond)")
print(' Retracting', r1)
self.KB.kb_retract(r1)
r2 = read.parse_input("fact: (talkslike profHammond)")
print(' Retracting', r2)
self.KB.kb_retract(r2)
ask1 = read.parse_input("fact: (isliterally ?X TonyStark)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertFalse(answer)
ask2 = read.parse_input("fact: (IronMan ?X)")
print(' Asking if', ask2)
answer = self.KB.kb_ask(ask2)
self.assertFalse(answer)
ask3 = read.parse_input("fact: (Avenger ?X)")
print(' Asking if', ask3)
answer = self.KB.kb_ask(ask3)
self.assertFalse(answer)
def test9(self):
"""this student generated test ensures retracting a fact that supports two or more facts or rules
successfully retracts all inferred facts and rules
"""
r1 = read.parse_input("fact: (techgenius profHammond)")
print(' Retracting', r1)
self.KB.kb_retract(r1)
ask1 = read.parse_input("fact: (employable ?X)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertFalse(answer)
ask2 = read.parse_input("fact: (smart ?X)")
print(' Asking if', ask2)
answer = self.KB.kb_ask(ask2)
self.assertFalse(answer)
def test10(self):
"""this student generated test ensures the inference engine is working at a basic level"""
ask1 = read.parse_input("fact: (Avenger ?X)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertEqual(str(answer[0]), "?X : profHammond")
ask2 = read.parse_input("fact: (smart ?X)")
print(' Asking if', ask2)
answer = self.KB.kb_ask(ask2)
self.assertEqual(str(answer[0]), "?X : profHammond")
ask3 = read.parse_input("fact: (employable ?X)")
print(' Asking if', ask3)
answer = self.KB.kb_ask(ask3)
self.assertEqual(str(answer[0]), "?X : profHammond")
class KBTest(unittest.TestCase):
def setUp(self):
# Assert starter facts
file = 'geography.txt'
self.data = read.read_tokenize(file)
data = read.read_tokenize(file)
self.KB = KnowledgeBase([], [])
for item in data:
if isinstance(item, Fact) or isinstance(item, Rule):
self.KB.kb_assert(item)
def test1(self):
ask1 = read.parse_input("fact: (cityof chicago ?y)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertEqual(str(answer[0]), "?Y : illinois")
ask2 = read.parse_input("fact: (capitalof ?x newyork)")
print(' Asking if', ask2)
answer = self.KB.kb_ask(ask2)
self.assertEqual(str(answer[0]), "?X : albany")
ask3 = read.parse_input("fact: (stateof illinois ?y)")
print(' Asking if', ask3)
answer = self.KB.kb_ask(ask3)
self.assertEqual(str(answer[0]), "?Y : usa")
def test2(self):
ask0 = read.parse_input("fact: (cityof springfield ?y)")
print(' Asking if', ask0)
answer = self.KB.kb_ask(ask0)
self.assertEqual(str(answer[0]), "?Y : illinois")
ask1 = read.parse_input("fact: (cityincountry albany ?y)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertEqual(str(answer[0]), "?Y : usa")
r1 = read.parse_input("fact: (cityof albany newyork)")
print(' Retracting', r1)
self.KB.kb_retract(r1)
answer2 = self.KB.kb_ask(ask1)
self.assertEqual(str(answer[0]), "?Y : usa")
r2 = read.parse_input("fact: (capitalof albany newyork)")
print(' Retracting', r2)
self.KB.kb_retract(r2)
answer2 = self.KB.kb_ask(ask1)
self.assertEqual(
str(answer[0]),
"?Y : usa") #still supported by rule for capitols and citys
ask2 = read.parse_input("fact: capitalof albany newyork")
answer3 = self.KB.kb_ask(ask2)
self.assertEqual(answer3, [])
def test3(self):
r1 = read.parse_input("fact: (cityof nyc newyork)")
r2 = read.parse_input("fact: (cityof manhattan newyork)")
r3 = read.parse_input("fact: (capitalof albany newyork)")
print(' Retracting', r1)
self.KB.kb_retract(r1)
print(' Retracting', r2)
self.KB.kb_retract(r2)
print(' Retracting', r3)
self.KB.kb_retract(r3)
ask1 = read.parse_input("fact: cityincountry nyc ?Y")
answer1 = self.KB.kb_ask(ask1)
self.assertEqual(str(answer1[0]), "?Y : usa")
class KBTest(unittest.TestCase):
def setUp(self):
# Assert starter facts
file = 'statements_kb4.txt'
self.data = read.read_tokenize(file)
data = read.read_tokenize(file)
self.KB = KnowledgeBase([], [])
for item in data:
if isinstance(item, Fact) or isinstance(item, Rule):
self.KB.kb_assert(item)
def test1(self):
# Did the student code contain syntax errors, AttributeError, etc.
ask1 = read.parse_input("fact: (motherof ada ?X)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertEqual(str(answer[0]), "?X : bing")
def test2(self):
# Can fc_infer actually infer
ask1 = read.parse_input("fact: (grandmotherof ada ?X)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertEqual(str(answer[0]), "?X : felix")
self.assertEqual(str(answer[1]), "?X : chen")
def test3(self):
# Does retract actually retract things
r1 = read.parse_input("fact: (motherof ada bing)")
print(' Retracting', r1)
self.KB.kb_retract(r1)
ask1 = read.parse_input("fact: (grandmotherof ada ?X)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertEqual(len(answer), 1)
self.assertEqual(str(answer[0]), "?X : felix")
def test4(self):
# makes sure retract does not retract supported fact
ask1 = read.parse_input("fact: (grandmotherof ada ?X)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertEqual(str(answer[0]), "?X : felix")
self.assertEqual(str(answer[1]), "?X : chen")
r1 = read.parse_input("fact: (grandmotherof ada chen)")
print(' Retracting', r1)
self.KB.kb_retract(r1)
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertEqual(str(answer[0]), "?X : felix")
self.assertEqual(str(answer[1]), "?X : chen")
def test5(self):
# makes sure retract does not deal with rules
ask1 = read.parse_input("fact: (parentof ada ?X)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertEqual(str(answer[0]), "?X : bing")
r1 = read.parse_input("rule: ((motherof ?x ?y)) -> (parentof ?x ?y)")
print(' Retracting', r1)
self.KB.kb_retract(r1)
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertEqual(str(answer[0]), "?X : bing")
def test6(self):
"""this student generated test ensures retract only removes facts and rules that are supported by
1 or less fact-rule pairs
"""
r1 = read.parse_input("fact: (dresslike profHammond TonyStark)")
print(' Retracting', r1)
self.KB.kb_retract(r1)
ask1 = read.parse_input("fact: (isliterally ?X TonyStark)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertEqual(str(answer[0]), "?X : profHammond")
ask2 = read.parse_input("fact: (resembles profHammond ?Y)")
print(' Asking if', ask2)
answer = self.KB.kb_ask(ask2)
self.assertFalse(answer)
def test7(self):
"""this student generated test ensures retracting the 2nd fact in the lhs of a rule
successfully retracts the final inferred fact but re-assertion re-infers the fact
"""
r1 = read.parse_input("fact: (lookslike profHammond TonyStark)")
print(' Retracting', r1)
self.KB.kb_retract(r1)
ask1 = read.parse_input("fact: (resembles profHammond ?Y)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertFalse(answer)
a1 = read.parse_input("fact: (lookslike profHammond TonyStark)")
print(' Reasserting', a1)
self.KB.kb_assert(a1)
ask2 = read.parse_input("fact: (resembles profHammond ?Y)")
print(' Asking if', ask2)
answer = self.KB.kb_ask(ask2)
self.assertEqual(str(answer[0]), "?Y : TonyStark")
def test8(self):
"""this student generated test ensures retracting a fact that supports two or more facts or rules
successfully retracts all inferred facts and rules
"""
r1 = read.parse_input("fact: (techgenius profHammond)")
print(' Retracting', r1)
self.KB.kb_retract(r1)
ask1 = read.parse_input("fact: (employable ?X)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertFalse(answer)
ask2 = read.parse_input("fact: (smart ?X)")
print(' Asking if', ask2)
answer = self.KB.kb_ask(ask2)
self.assertFalse(answer)
def test9(self):
"""this student generated test ensures the inference engine is working at a basic level"""
ask1 = read.parse_input("fact: (Avenger ?X)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertEqual(str(answer[0]), "?X : profHammond")
ask2 = read.parse_input("fact: (smart ?X)")
print(' Asking if', ask2)
answer = self.KB.kb_ask(ask2)
self.assertEqual(str(answer[0]), "?X : profHammond")
ask3 = read.parse_input("fact: (employable ?X)")
print(' Asking if', ask3)
answer = self.KB.kb_ask(ask3)
self.assertEqual(str(answer[0]), "?X : profHammond")
def main():
# Assert starter facts
file = 'statements_kb2.txt'
data = read.read_tokenize(file)
KB = KnowledgeBase([], [])
for dtype, item in data:
if dtype == read.FACT:
KB.kb_assert(item)
# KB demonstration
# Ask for one of the starter facts
print "Starting basic KB demonstration"
_, ask1 = read.parse_input("fact: (hero ?x)")
print " Asking if", ask1
answer = KB.kb_ask(ask1)
#pprint_justification(answer)
print ("Basic demonstration of KB complete" if answer else "ERROR: KB demonstration failed") + "\n"
print "Starting Test 1"
_, test1 = read.parse_input("fact: (hero Ai)")
print " Retracting", test1
# KB.kb_retract(Statement(test1))
KB.kb_retract(test1)
answer = KB.kb_ask(ask1)
# pprint_justification(answer)
print (("Fail" if answer else "Pass") + " Test 1\n")
print "Starting Test 2"
fail = True
for dtype, item in data:
if dtype == read.RULE:
KB.kb_assert(item)
_, test2_1 = read.parse_input("fact: (strong ?x)")
print " Asking", test2_1
answer = KB.kb_ask(test2_1)
#pprint_justification(answer)
if answer and len(answer)==1 and answer[0]['?x'] == 'Ai':
print " Pass Part 1"
_, test2_2 = read.parse_input("fact: (inst Sarorah ?x)")
print " Asking", test2_2
answer = KB.kb_ask(test2_2)
#pprint_justification(answer)
if answer and len(answer)==2 and (answer[0]['?x'] == 'Sorceress' or answer[0]['?x'] == 'Wizard'):
print " Pass Part 2"
_, test2_3 = read.parse_input("fact: (dead ?dragon)")
print " Asking", test2_3
answer = KB.kb_ask(test2_3)
#pprint_justification(answer)
if not answer:
print " Pass Part 3"
_, assert_hero = read.parse_input("fact: (hero Ai)")
print " Asserting", assert_hero
KB.kb_assert(assert_hero)
_, test2_4 = read.parse_input("fact: (dead ?dragon)")
print " Asking", test2_4
answer = KB.kb_ask(test2_4)
#pprint_justification(answer)
if answer and len(answer)==1 and answer[0]['?dragon'] == 'Nosliw':
print " Pass Part 4\nPass Test 2\n"
fail = False
if fail:
print "Fail Test 2\n"
print "Starting Test 3"
fail = True
_, possesses = read.parse_input("fact: (possesses Ai Loot)")
print " Retracting", possesses
KB.kb_retract(possesses)
_, test3_1 = read.parse_input("fact: (dead ?dragon)")
print " Asking", test3_1
answer = KB.kb_ask(test3_1)
# pprint_justification(answer)
if not answer:
print " Pass Part 1"
print " Asserting", possesses
KB.kb_assert(possesses)
_, sleeping = read.parse_input("fact: (sleeping Nosliw)")
_, safe = read.parse_input("rule: (sleeping Nosliw) -> (safe HappyDale)")
print " Asserting", sleeping
KB.kb_assert(sleeping)
print " Asserting", safe
KB.kb_assert(safe)
print " Retracting", possesses
KB.kb_retract(possesses)
_, possesses = read.parse_input("fact: (possesses Ai Loot)")
_, test3_2 = read.parse_input("fact: (safe ?town)")
print " Asking", test3_2
answer = KB.kb_ask(test3_2)
#pprint_justification(answer)
if answer and len(answer)==1 and answer[0]['?town'] == 'HappyDale':
print " Pass Part 2\nPass Test 3\n"
fail = False
if fail:
print "Fail Test 3\n"
class KBTest(unittest.TestCase):
def setUp(self):
# Assert starter facts
file = 'statements_kb4.txt'
self.data = read.read_tokenize(file)
data = read.read_tokenize(file)
self.KB = KnowledgeBase([], [])
for item in data:
if isinstance(item, Fact) or isinstance(item, Rule):
self.KB.kb_assert(item)
def test1(self):
ask1 = read.parse_input("fact: (motherof ada ?X)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertEqual(len(answer), 1)
self.assertEqual(str(answer[0]), "?X : bing")
def test2(self):
ask1 = read.parse_input("fact: (grandmotherof ada ?X)")
print(' ---Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertEqual(len(answer), 2)
self.assertEqual(str(answer[0]), "?X : felix")
self.assertEqual(str(answer[1]), "?X : chen")
def test_custom_test(self):
ask1 = read.parse_input("fact: (parentof ada ?X)")
print(' #Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertEqual(len(answer), 1)
self.assertEqual(str(answer[0]), "?X : bing")
for fact in self.KB.facts:
print('----fact in kb:', fact)
for rule in self.KB.rules:
print('----rule in kb:', rule)
def test3(self):
r1 = read.parse_input("fact: (motherof ada bing)")
print(' Retracting', r1)
self.KB.kb_retract(r1)
ask1 = read.parse_input("fact: (grandmotherof ada ?X)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertEqual(len(answer), 1)
self.assertEqual(str(answer[0]), "?X : felix")
def test4(self):
r1 = read.parse_input("fact: (grandmotherof ada chen)")
print(' Retracting', r1)
self.KB.kb_retract(r1)
ask1 = read.parse_input("fact: (grandmotherof ada ?X)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertEqual(len(answer), 2)
self.assertEqual(str(answer[0]), "?X : felix")
self.assertEqual(str(answer[1]), "?X : chen")
def test5(self):
r1 = read.parse_input("rule: ((motherof ?x ?y)) -> (parentof ?x ?y)")
print(' Retracting', r1)
self.KB.kb_retract(r1)
ask1 = read.parse_input("fact: (parentof ada ?X)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertEqual(len(answer), 1)
self.assertEqual(str(answer[0]), "?X : bing")
class KBTest(unittest.TestCase):
def setUp(self):
# Assert starter facts
file = 'statements_kb4.txt'
self.data = read.read_tokenize(file)
data = read.read_tokenize(file)
self.KB = KnowledgeBase([], [])
for item in data:
if isinstance(item, Fact) or isinstance(item, Rule):
self.KB.kb_assert(item)
def test1(self):
# Did the student code contain syntax errors, AttributeError, etc.
ask1 = read.parse_input("fact: (motherof ada ?X)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertEqual(str(answer[0]), "?X : bing")
def test2(self):
# Can fc_infer actually infer
ask1 = read.parse_input("fact: (grandmotherof ada ?X)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertEqual(str(answer[0]), "?X : felix")
self.assertEqual(str(answer[1]), "?X : chen")
def test3(self):
# Does retract actually retract things
r1 = read.parse_input("fact: (motherof ada bing)")
print(' Retracting', r1)
self.KB.kb_retract(r1)
ask1 = read.parse_input("fact: (grandmotherof ada ?X)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertEqual(len(answer), 1)
self.assertEqual(str(answer[0]), "?X : felix")
def test4(self):
# makes sure retract does not retract supported fact
ask1 = read.parse_input("fact: (grandmotherof ada ?X)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertEqual(str(answer[0]), "?X : felix")
self.assertEqual(str(answer[1]), "?X : chen")
r1 = read.parse_input("fact: (grandmotherof ada chen)")
print(' Retracting', r1)
self.KB.kb_retract(r1)
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertEqual(str(answer[0]), "?X : felix")
self.assertEqual(str(answer[1]), "?X : chen")
def test5(self):
# makes sure retract does not deal with rules
ask1 = read.parse_input("fact: (parentof ada ?X)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertEqual(str(answer[0]), "?X : bing")
r1 = read.parse_input("rule: ((motherof ?x ?y)) -> (parentof ?x ?y)")
print(' Retracting', r1)
self.KB.kb_retract(r1)
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertEqual(str(answer[0]), "?X : bing")
def test6(self):
# infer a new fact from a rule with 1 lhs statement
ask1 = read.parse_input("fact: (parentof ada ?X)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertEqual(str(answer[0]), "?X : bing")
def test7(self):
"""this student generated test ensures retract only removes facts and rules that are supported by
1 or less fact-rule pairs
"""
r1 = read.parse_input("fact: (dresslike profHammond TonyStark)")
read1 = self.KB._get_fact(r1)
print(len(read1.supported_by))
print(read1.supports_rules)
print(' Retracting', r1)
self.KB.kb_retract(r1)
ask1 = read.parse_input("fact: (isliterally ?X TonyStark)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertEqual(str(answer[0]), "?X : profHammond")
ask2 = read.parse_input("fact: (resembles profHammond ?Y)")
print(' Asking if', ask2)
answer = self.KB.kb_ask(ask2)
print(answer)
self.assertFalse(answer)
class KBTest(unittest.TestCase):
def setUp(self):
# Assert starter facts
file = 'statements_kb6.txt'
self.data = read.read_tokenize(file)
data = read.read_tokenize(file)
self.KB = KnowledgeBase([], [])
for item in data:
if isinstance(item, Fact) or isinstance(item, Rule):
self.KB.kb_assert(item)
def test66(self):
for f in self.KB.facts:
if f.supports_rules:
print(f.statement)
r1 = read.parse_input("fact: (dresslike profHammond TonyStark)")
print(' Retracting', r1)
self.KB.kb_retract(r1)
ask1 = read.parse_input("fact: (isliterally ?X TonyStark)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertEqual(str(answer[0]), "?X : profHammond")
ask2 = read.parse_input("fact: (resembles profHammond ?Y)")
print(' Asking if', ask2)
answer = self.KB.kb_ask(ask2)
self.assertFalse(answer)
for f in self.KB.facts:
#print(f.statement)
#if len(f.supported_by):
# print(f.supported_by[0])
print('-------------')
def test7(self):
r1 = read.parse_input("fact: (lookslike profHammond TonyStark)")
print(' Retracting', r1)
self.KB.kb_retract(r1)
ask1 = read.parse_input("fact: (resembles profHammond ?Y)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertFalse(answer)
a1 = read.parse_input("fact: (lookslike profHammond TonyStark)")
print(' Reasserting', a1)
self.KB.kb_assert(a1)
ask2 = read.parse_input("fact: (resembles profHammond ?Y)")
print(' Asking if', ask2)
answer = self.KB.kb_ask(ask2)
self.assertEqual(str(answer[0]), "?Y : TonyStark")
def test8(self):
r1 = read.parse_input("fact: (techgenius profHammond)")
print(' Retracting', r1)
self.KB.kb_retract(r1)
r2 = read.parse_input("fact: (talkslike profHammond)")
print(' Retracting', r2)
#self.KB.kb_retract(r2)
ask1 = read.parse_input("fact: (isliterally ?X TonyStark)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
#self.assertFalse(answer)
ask2 = read.parse_input("fact: (IronMan ?X)")
print(' Asking if', ask2)
answer = self.KB.kb_ask(ask2)
#self.assertFalse(answer)
ask3 = read.parse_input("fact: (Avenger ?X)")
print(' Asking if', ask3)
answer = self.KB.kb_ask(ask3)
#self.assertFalse(answer)
def test9(self):
r1 = read.parse_input("fact: (techgenius profHammond)")
print(' Retracting', r1)
self.KB.kb_retract(r1)
ask1 = read.parse_input("fact: (employable ?X)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertFalse(answer)
ask2 = read.parse_input("fact: (smart ?X)")
print(' Asking if', ask2)
answer = self.KB.kb_ask(ask2)
self.assertFalse(answer)
def test10(self):
ask1 = read.parse_input("fact: (Avenger ?X)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertEqual(str(answer[0]), "?X : profHammond")
ask2 = read.parse_input("fact: (smart ?X)")
print(' Asking if', ask2)
answer = self.KB.kb_ask(ask2)
self.assertEqual(str(answer[0]), "?X : profHammond")
ask3 = read.parse_input("fact: (employable ?X)")
print(' Asking if', ask3)
answer = self.KB.kb_ask(ask3)
self.assertEqual(str(answer[0]), "?X : profHammond")
print answer5
KB2 = KnowledgeBase([], [])
_, fact21 = read.parse_input("fact: (relaa A)")
_, fact22 = read.parse_input("fact: (relab A)")
_, rule21 = read.parse_input("rule: ((relaa ?x)) -> (good ?x)")
_, rule22 = read.parse_input("rule: ((relab ?x)) -> (good ?x)")
_, ask21 = read.parse_input("fact: (good ?x)")
KB2.kb_assert(fact21)
KB2.kb_assert(fact22)
KB2.kb_assert(rule21)
KB2.kb_assert(rule22)
answer6 = KB2.kb_ask(ask21)
print answer6
KB2.kb_retract(fact21)
answer7 = KB2.kb_ask(ask21)
print answer7
answer8 = not KB2.kb_ask(fact21)
print answer8
if answer1 and answer2 and answer3 and answer4 and answer5 and answer6 and answer7 and answer8:
print "pass test5"
exit(0)
else:
print "fail test5"
exit(1)
class KBTest(unittest.TestCase):
def setUp(self):
# Assert starter facts
file = 'statements_kb4.txt'
self.data = read.read_tokenize(file)
data = read.read_tokenize(file)
self.KB = KnowledgeBase([], [])
for item in data:
if isinstance(item, Fact) or isinstance(item, Rule):
self.KB.kb_assert(item)
def test1(self):
# Did the student code contain syntax errors, AttributeError, etc.
ask1 = read.parse_input("fact: (motherof ada ?X)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertEqual(str(answer[0]), "?X : bing")
def test2(self):
# Can fc_infer actually infer
ask1 = read.parse_input("fact: (grandmotherof ada ?X)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertEqual(str(answer[0]), "?X : felix")
self.assertEqual(str(answer[1]), "?X : chen")
def test3(self):
# Does retract actually retract things
r1 = read.parse_input("fact: (motherof ada bing)")
print(' Retracting', r1)
self.KB.kb_retract(r1)
ask1 = read.parse_input("fact: (grandmotherof ada ?X)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertEqual(len(answer), 1)
self.assertEqual(str(answer[0]), "?X : felix")
def test4(self):
# makes sure retract does not retract supported fact
ask1 = read.parse_input("fact: (grandmotherof ada ?X)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertEqual(str(answer[0]), "?X : felix")
self.assertEqual(str(answer[1]), "?X : chen")
r1 = read.parse_input("fact: (grandmotherof ada chen)")
print(' Retracting', r1)
self.KB.kb_retract(r1)
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertEqual(str(answer[0]), "?X : felix")
self.assertEqual(str(answer[1]), "?X : chen")
def test5(self):
# makes sure retract does not deal with rules
ask1 = read.parse_input("fact: (parentof ada ?X)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertEqual(str(answer[0]), "?X : bing")
r1 = read.parse_input("rule: ((motherof ?x ?y)) -> (parentof ?x ?y)")
print(' Retracting', r1)
self.KB.kb_retract(r1)
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertEqual(str(answer[0]), "?X : bing")
def test37(self):
r1 = read.parse_input("fact: (motherof ada bing)")
print(' Retracting', r1)
self.KB.kb_retract(r1)
ask1 = read.parse_input("fact: (parentof ada ?X)")
answer = self.KB.kb_ask(ask1)
print(' Answer is ', answer)
self.assertEqual(len(answer), 0)
def main():
# Assert starter facts
file = 'statements_kb2.txt'
data = read.read_tokenize(file)
KB = KnowledgeBase([], [])
for dtype, item in data:
if dtype == read.FACT:
KB.kb_assert(item)
# KB demonstration
# Ask for one of the starter facts
# print "Starting basic KB demonstration"
_, ask1 = read.parse_input("fact: (hero ?x)")
# print " Asking if", ask1
# answer = KB.kb_ask(ask1)
# # print answer
# pprint_justification(answer)
# print ("Basic demonstration of KB complete" if answer else "ERROR: KB demonstration failed") + "\n"
print "Starting Test 1"
_, test1 = read.parse_input("fact: (hero Ai)")
# print " Retracting", test1
KB.kb_retract(test1)
# print KB.facts
answer = KB.kb_ask(ask1)
# print answer
# pprint_justification(answer)
print(("Fail" if answer else "Pass") + " Test 1\n")
hai = Fact(test1).statement
print "Starting Test 2"
fail = True
for dtype, item in data:
if dtype == read.RULE:
# print "the item is", item
KB.kb_assert(item)
# if not factq(item):
# print "SCREAM", Rule(item)
# print "LHS first term is", Rule(item).lhs[0]
# first_term = Rule(item).lhs[0]
# bound = match(hai, first_term)
# if bound:
# print "bindings are", bound
# insta = instantiate(Rule(item).lhs[0], bound)
# print "INSTA", insta
# insta2 = instantiate(Rule(item).rhs, bound)
# print "INSTA2", insta2
# new_lhs = copy.deepcopy(Rule(item).lhs)
# new_lhs.remove(first_term)
# print "new lhs", new_lhs
# supby = [[Rule(item), hai]]
# newfact = Fact(insta2, supby)
# print "newfact sup by is", newfact.supported_by
# print newfact.statement
# # print "now it's", Rule(item)
# newrulelist = [[insta.predicate], [insta2.predicate, insta2.terms]]
# print "list is", newrulelist
# # newrule = Rule(newrulelist)
# # else:
# # print "DIDN'T MATCH"
_, test2_1 = read.parse_input("fact: (strong ?x)")
print " Asking", test2_1
answer = KB.kb_ask(test2_1)
#pprint_justification(answer)
if answer and len(answer) == 1 and answer[0]['?x'] == 'Ai':
print " Pass Part 1"
_, test2_2 = read.parse_input("fact: (inst Sarorah ?x)")
print " Asking", test2_2
answer = KB.kb_ask(test2_2)
#pprint_justification(answer)
if answer and len(answer) == 2 and (answer[0]['?x'] == 'Sorceress'
or answer[0]['?x'] == 'Wizard'):
print " Pass Part 2"
_, test2_3 = read.parse_input("fact: (dead ?dragon)")
print " Asking", test2_3
answer = KB.kb_ask(test2_3)
#pprint_justification(answer)
if not answer:
print " Pass Part 3"
_, assert_hero = read.parse_input("fact: (hero Ai)")
print " Asserting", assert_hero
KB.kb_assert(assert_hero)
_, test2_4 = read.parse_input("fact: (dead ?dragon)")
print " Asking", test2_4
answer = KB.kb_ask(test2_4)
# pprint_justification(answer)
if answer and len(
answer) == 1 and answer[0]['?dragon'] == 'Nosliw':
print " Pass Part 4\nPass Test 2\n"
fail = False
if fail:
print "Fail Test 2\n"
# DEBUGGING FOR TEST 2
# answer = KB.kb_ask(test2_4)
for f in KB.facts:
print f.statement, "\n"
f = KB.facts[2]
print "this is the fact", f
print "what", isinstance(f.statement, Statement)
dummy = Fact(['possesses', 'Ai', 'code'])
print dummy
dummy2 = Fact(['a', 'b', 'c', 'd'])
print "HELLO", KB._get_fact(dummy)
# print "the fact", f.statement
# for s in f.supported_by[0]:
# print s
# print "consider the fact", f.statement
# print f.asserted
# for sf in f.supported_by:
# print sf, "\n"
print "Starting Test 3"
fail = True
_, possesses = read.parse_input("fact: (possesses Ai Loot)")
print " Retracting", possesses
KB.kb_retract(possesses)
_, test3_1 = read.parse_input("fact: (dead ?dragon)")
print " Asking", test3_1
answer = KB.kb_ask(test3_1)
print "I HATE IT", factq(['a'])
#pprint_justification(answer)
if not answer:
print " Pass Part 1"
print " Asserting", possesses
KB.kb_assert(possesses)
_, sleeping = read.parse_input("fact: (sleeping Nosliw)")
_, safe = read.parse_input(
"rule: (sleeping Nosliw) -> (safe HappyDale)")
print " Asserting", sleeping
KB.kb_assert(sleeping)
print " Asserting", safe
KB.kb_assert(safe)
print " Retracting", possesses
KB.kb_retract(possesses)
_, possesses = read.parse_input("fact: (possesses Ai Loot)")
_, test3_2 = read.parse_input("fact: (safe ?town)")
print " Asking", test3_2
answer = KB.kb_ask(test3_2)
#pprint_justification(answer)
if answer and len(answer) == 1 and answer[0]['?town'] == 'HappyDale':
print " Pass Part 2\nPass Test 3\n"
fail = False
if fail:
print "Fail Test 3\n"
class KBTest(unittest.TestCase):
def setUp(self):
# Assert starter facts
file = 'statements_kb4.txt'
self.data = read.read_tokenize(file)
data = read.read_tokenize(file)
self.KB = KnowledgeBase([], [])
for item in data:
if isinstance(item, Fact) or isinstance(item, Rule):
self.KB.kb_assert(item)
def test1(self):
# Did the student code contain syntax errors, AttributeError, etc.
ask1 = read.parse_input("fact: (motherof ada ?X)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
#pprint_justification(answer)
self.assertEqual(str(answer[0]), "?X : bing")
def test2(self):
# Can fc_infer actually infer
ask1 = read.parse_input("fact: (grandmotherof ada ?X)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
#pprint_justification(answer)
self.assertEqual(str(answer[0]), "?X : felix")
self.assertEqual(str(answer[1]), "?X : chen")
def test3(self):
# Does retract actually retract things
r1 = read.parse_input("fact: (motherof ada bing)")
print(' Retracting', r1)
self.KB.kb_retract(r1)
ask1 = read.parse_input("fact: (grandmotherof ada ?X)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
#pprint_justification(answer)
self.assertEqual(len(answer), 1)
self.assertEqual(str(answer[0]), "?X : felix")
def test4(self):
# makes sure retract does not retract supported fact
ask1 = read.parse_input("fact: (grandmotherof ada ?X)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
#pprint_justification(answer)
self.assertEqual(str(answer[0]), "?X : felix")
self.assertEqual(str(answer[1]), "?X : chen")
r1 = read.parse_input("fact: (grandmotherof ada chen)")
print(' Retracting', r1)
self.KB.kb_retract(r1)
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
#pprint_justification(answer)
self.assertEqual(str(answer[0]), "?X : felix")
self.assertEqual(str(answer[1]), "?X : chen")
def test5(self):
# makes sure retract does not deal with rules
ask1 = read.parse_input("fact: (parentof ada ?X)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
#pprint_justification(answer)
self.assertEqual(str(answer[0]), "?X : bing")
r1 = read.parse_input("rule: ((motherof ?x ?y)) -> (parentof ?x ?y)")
print(' Retracting', r1)
self.KB.kb_retract(r1)
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
#pprint_justification(answer)
self.assertEqual(str(answer[0]), "?X : bing")
def test6(self):
r1 = read.parse_input("fact: (motherof bing chen)")
print(' Retracting', r1)
self.KB.kb_retract(r1)
ask1 = read.parse_input("fact: (grandmotherof ada ?X)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertEqual(len(answer), 1)
self.assertEqual(str(answer[0]), "?X : felix")
def test7(self):
in1 = read.parse_input("fact: (sisters bing dannydevito)")
print(' Asserting in', in1)
self.KB.kb_assert(in1)
a1 = read.parse_input("fact: (auntof dannydevito ?X)")
print(' Asking if', a1)
answer = self.KB.kb_ask(a1)
self.assertEqual(str(answer[0]), "?X : chen")
r1 = read.parse_input("fact: (sisters bing dannydevito)")
print(' Retracting', r1)
self.KB.kb_retract(r1)
a2 = read.parse_input("fact: (auntof dannydevito ?X)")
print(' Asking if', a2)
answer = self.KB.kb_ask(a2)
self.assertEqual(answer, [])
def test8(self):
# tests with a new rule that makes new inferences
in1 = read.parse_input("rule: (grandmotherof ?x ?y) -> (homie ?y)")
print(' Asserting in', in1)
self.KB.kb_assert(in1)
a1 = read.parse_input("fact: (homie ?X)")
print(' Asking if', a1)
answer = self.KB.kb_ask(a1)
self.assertEqual(str(answer[0]), "?X : felix")
self.assertEqual(str(answer[1]), "?X : chen")
r1 = read.parse_input("fact: (motherof ada bing)")
print(' Retracting', r1)
self.KB.kb_retract(r1)
a2 = read.parse_input("fact: (homie ?X)")
print(' Asking if', a2)
answer = self.KB.kb_ask(a2)
self.assertEqual(str(answer[0]), "?X : felix")
def test9(self):
in1 = read.parse_input("fact: (motherof chen jesus)")
print(' Asserting in', in1)
self.KB.kb_assert(in1)
in2 = read.parse_input(
"rule: ((parentof ?x ?y) (parentof ?y ?z) (parentof ?z ?zz)) -> (greatgrandmotherof ?x ?zz)"
)
print(' Asserting in', in2)
self.KB.kb_assert(in2)
a1 = read.parse_input("fact: (greatgrandmotherof ?X jesus)")
print(' Asking if', a1)
answer = self.KB.kb_ask(a1)
self.assertEqual(str(answer[0]), "?X : ada")
r1 = read.parse_input("fact: (motherof ada bing)")
print(' Retracting', r1)
self.KB.kb_retract(r1)
a2 = read.parse_input("fact: (greatgrandmotherof ?X jesus)")
print(' Asking if', a2)
answer = self.KB.kb_ask(a2)
self.assertEqual(answer, [])
class KBTest(unittest.TestCase):
def setUp(self):
# Assert starter facts
file = 'statements_kb5.txt'
self.data = read.read_tokenize(file)
data = read.read_tokenize(file)
self.KB = KnowledgeBase([], [])
for item in data:
if isinstance(item, Fact) or isinstance(item, Rule):
self.KB.kb_assert(item)
# for f in self.KB.facts:
# print(f.statement)
# def test11(self):
# print("Hello Michael")
# print(len(self.KB.facts))
# # print(self.KB.facts)
# print(len(self.KB.rules))
# # print(self.KB.rules)
# ask1 = read.parse_input("fact: (goodman ?X)")
# print(' Asking if', ask1)
# answer = self.KB.kb_ask(ask1)
# self.assertEqual(str(answer[0]), "?X : a")
# def test1(self):
# # Did the student code contain syntax errors, AttributeError, etc.
# ask1 = read.parse_input("fact: (motherof ada ?X)")
# print(' Asking if', ask1)
# answer = self.KB.kb_ask(ask1)
# self.assertEqual(str(answer[0]), "?X : bing")
#
# def test2(self):
# # Can fc_infer actually infer
# print("Hello Michael")
# print(len(self.KB.facts))
# # print(self.KB.facts)
# print(len(self.KB.rules))
# # print(self.KB.rules)
# ask1 = read.parse_input("fact: (grandmotherof ada ?X)")
# print(' Asking if', ask1)
# answer = self.KB.kb_ask(ask1)
# self.assertEqual(str(answer[0]), "?X : felix")
# self.assertEqual(str(answer[1]), "?X : chen")
#
# def test3(self):
# # Does retract actually retract things
# r1 = read.parse_input("fact: (motherof ada bing)")
# # for f in self.KB.facts:
# # print(f.statement)
# # print(f.asserted)
# # print(f.supported_by)
# self.KB.kb_retract(r1)
# ask1 = read.parse_input("fact: (grandmotherof ada ?X)")
# # print(len(self.KB.facts))
# # for f in self.KB.facts:
# # print(f.statement)
# # print(f.asserted)
# # print(len(f.supported_by))
# # print(f.supported_by)
# print(' Asking if', ask1)
# answer = self.KB.kb_ask(ask1)
# self.assertEqual(len(answer), 1)
# self.assertEqual(str(answer[0]), "?X : felix")
#
# def test4(self):
# # makes sure retract does not retract supported fact
# ask1 = read.parse_input("fact: (grandmotherof ada ?X)")
# print(' Asking if', ask1)
# answer = self.KB.kb_ask(ask1)
# self.assertEqual(str(answer[0]), "?X : felix")
# self.assertEqual(str(answer[1]), "?X : chen")
#
# for f in self.KB.facts:
# print(f.statement)
# print(f.asserted)
# print(len(f.supported_by))
#
# r1 = read.parse_input("fact: (grandmotherof ada chen)")
# print(' Retracting', r1)
# self.KB.kb_retract(r1)
#
# for f in self.KB.facts:
# print(f.statement)
# print(f.asserted)
# print(len(f.supported_by))
#
# print(' Asking if', ask1)
# answer = self.KB.kb_ask(ask1)
# self.assertEqual(str(answer[0]), "?X : felix")
# self.assertEqual(str(answer[1]), "?X : chen")
#
# def test5(self):
# # makes sure retract does not deal with rules
# ask1 = read.parse_input("fact: (parentof ada ?X)")
# print(' Asking if', ask1)
# answer = self.KB.kb_ask(ask1)
# self.assertEqual(str(answer[0]), "?X : bing")
# r1 = read.parse_input("rule: ((motherof ?x ?y)) -> (parentof ?x ?y)")
# print(' Retracting', r1)
# self.KB.kb_retract(r1)
# print(' Asking if', ask1)
# answer = self.KB.kb_ask(ask1)
# self.assertEqual(str(answer[0]), "?X : bing")
# I got these tests from the very helpful Li Keen Lim on piazza!
def test6(self):
"""this student generated test ensures retract only removes facts and rules that are supported by
1 or less fact-rule pairs
"""
print(len(self.KB.facts))
print(len(self.KB.rules))
# for f in self.KB.facts:
# print(f)
# print(len(f.supported_by))
# print(f.asserted)
#
# for r in self.KB.rules:
# print(r.lhs,r.rhs)
# print(len(r.supported_by))
# print(r.asserted)
r1 = read.parse_input("fact: (dresslike profHammond TonyStark)")
print(' Retracting', r1)
self.KB.kb_retract(r1)
# for f in self.KB.facts:
# print(f)
# print(len(f.supported_by))
# print(f.asserted)
#
# for r in self.KB.rules:
# print(r.lhs,r.rhs)
# print(len(r.supported_by))
# print(r.asserted)
print(len(self.KB.facts))
print(len(self.KB.rules))
ask1 = read.parse_input("fact: (isliterally ?X TonyStark)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertEqual(str(answer[0]), "?X : profHammond")
# print(answer[0])
ask2 = read.parse_input("fact: (resembles profHammond ?Y)")
print(' Asking if', ask2)
answer = self.KB.kb_ask(ask2)
self.assertFalse(answer)
def test7(self):
"""this student generated test ensures retracting the 2nd fact in the lhs of a rule
successfully retracts the final inferred fact but re-assertion re-infers the fact
"""
r1 = read.parse_input("fact: (lookslike profHammond TonyStark)")
print(' Retracting', r1)
self.KB.kb_retract(r1)
ask1 = read.parse_input("fact: (resembles profHammond ?Y)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertFalse(answer)
a1 = read.parse_input("fact: (lookslike profHammond TonyStark)")
print(' Reasserting', a1)
self.KB.kb_assert(a1)
ask2 = read.parse_input("fact: (resembles profHammond ?Y)")
print(' Asking if', ask2)
answer = self.KB.kb_ask(ask2)
self.assertEqual(str(answer[0]), "?Y : TonyStark")
def test8(self):
"""this student generated test ensures retracting a fact that supports inferences 2 links away
also retracts all facts down that chain
"""
print(len(self.KB.facts))
print(len(self.KB.rules))
for f in self.KB.facts:
print(f)
print(len(f.supported_by))
r1 = read.parse_input("fact: (techgenius profHammond)")
print(' Retracting', r1)
self.KB.kb_retract(r1)
print(len(self.KB.facts))
print(len(self.KB.rules))
for f in self.KB.facts:
print(f)
print(len(f.supported_by))
r2 = read.parse_input("fact: (talkslike profHammond TonyStark)")
print(' Retracting', r2)
self.KB.kb_retract(r2)
ask1 = read.parse_input("fact: (isliterally ?X TonyStark)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertFalse(answer)
ask2 = read.parse_input("fact: (IronMan ?X)")
print(' Asking if', ask2)
answer = self.KB.kb_ask(ask2)
self.assertFalse(answer)
ask3 = read.parse_input("fact: (Avenger ?X)")
print(' Asking if', ask3)
answer = self.KB.kb_ask(ask3)
self.assertFalse(answer)
def test9(self):
"""this student generated test ensures retracting a fact that supports two or more facts or rules
successfully retracts all inferred facts and rules
"""
r1 = read.parse_input("fact: (techgenius profHammond)")
print(' Retracting', r1)
self.KB.kb_retract(r1)
ask1 = read.parse_input("fact: (employable ?X)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertFalse(answer)
ask2 = read.parse_input("fact: (smart ?X)")
print(' Asking if', ask2)
answer = self.KB.kb_ask(ask2)
self.assertFalse(answer)
def test10(self):
"""this student generated test ensures the inference engine is working at a basic level"""
ask1 = read.parse_input("fact: (Avenger ?X)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertEqual(str(answer[0]), "?X : profHammond")
ask2 = read.parse_input("fact: (smart ?X)")
print(' Asking if', ask2)
answer = self.KB.kb_ask(ask2)
self.assertEqual(str(answer[0]), "?X : profHammond")
ask3 = read.parse_input("fact: (employable ?X)")
print(' Asking if', ask3)
answer = self.KB.kb_ask(ask3)
self.assertEqual(str(answer[0]), "?X : profHammond")
class CustomTests3(unittest.TestCase):
def setUp(self):
file = 'statements_kb3.txt'
self.data = read.read_tokenize(file)
data = read.read_tokenize(file)
self.KB = KnowledgeBase([], [])
for item in data:
if isinstance(item, Fact) or isinstance(item, Rule):
self.KB.kb_assert(item)
def test1(self):
ask1 = read.parse_input("fact: (goodman ?X)")
answer1 = self.KB.kb_ask(ask1)
self.assertEqual(len(answer1), 1)
self.assertEqual(str(answer1[0]), "?X : a")
def test2(self):
fact1 = read.parse_input("fact: (goodman a)")
self.KB.kb_retract(fact1)
ask1 = read.parse_input("fact: (goodman ?X)")
answer1 = self.KB.kb_ask(ask1)
self.assertEqual(len(answer1), 1)
self.assertEqual(str(answer1[0]), "?X : a")
def test3(self):
fact1 = read.parse_input("fact: (hero a)")
fact2 = read.parse_input("fact: (person a)")
self.KB.kb_retract(fact1)
self.KB.kb_retract(fact2)
ask1 = read.parse_input("fact: (hero ?X)")
ask2 = read.parse_input("fact: (person ?X)")
answer1 = self.KB.kb_ask(ask1)
answer2 = self.KB.kb_ask(ask2)
self.assertEqual(len(answer1), 0)
self.assertEqual(len(answer2), 0)
def test4(self):
fact1 = read.parse_input("fact: (hero a)")
fact2 = read.parse_input("fact: (person a)")
fact3 = read.parse_input("fact: (goodman a)")
self.KB.kb_retract(fact1)
self.KB.kb_retract(fact2)
self.KB.kb_retract(fact3)
ask1 = read.parse_input("fact: (goodman ?X")
answer1 = self.KB.kb_ask(ask1)
self.assertEqual(len(answer1), 0)
def test5(self):
fact1 = read.parse_input("fact: (hero a)")
fact2 = read.parse_input("fact: (person a)")
self.KB.kb_retract(fact1)
self.KB.kb_retract(fact2)
ask1 = read.parse_input("fact: (goodman ?X")
answer1 = self.KB.kb_ask(ask1)
self.assertEqual(len(answer1), 1)
self.assertEqual(str(answer1[0]), "?X : a")
fact3 = read.parse_input("fact: (goodman a)")
self.KB.kb_retract(fact3)
ask1 = read.parse_input("fact: (goodman ?X")
answer1 = self.KB.kb_ask(ask1)
self.assertEqual(len(answer1), 0)
def test6(self):
fact1 = read.parse_input("fact: (human a)")
rule1 = read.parse_input("rule: ((human ?y)) -> (person ?y)")
self.KB.kb_assert(fact1)
self.KB.kb_assert(rule1)
remove1 = read.parse_input("fact: (person a")
self.KB.kb_retract(remove1)
ask1 = read.parse_input("fact: (goodman ?X")
answer1 = self.KB.kb_ask(ask1)
self.assertEqual(len(answer1), 1)
self.assertEqual(str(answer1[0]), "?X : a")
remove1 = read.parse_input("fact: (human a")
self.KB.kb_retract(remove1)
ask1 = read.parse_input("fact: (goodman ?X")
answer1 = self.KB.kb_ask(ask1)
self.assertEqual(len(answer1), 1)
self.assertEqual(str(answer1[0]), "?X : a")
remove1 = read.parse_input("fact: (person a")
self.KB.kb_retract(remove1)
ask1 = read.parse_input("fact: (goodman ?X")
answer1 = self.KB.kb_ask(ask1)
self.assertEqual(len(answer1), 1)
self.assertEqual(str(answer1[0]), "?X : a")
remove1 = read.parse_input("fact: (goodman a")
for x in self.KB.facts:
if x == remove1:
print("Asserted?")
print(x.asserted)
self.KB.kb_retract(remove1)
ask1 = read.parse_input("fact: (goodman ?X")
answer1 = self.KB.kb_ask(ask1)
self.assertEqual(len(answer1), 0)
def test7(self):
remove1 = read.parse_input("fact: (goodman a")
self.KB.kb_retract(remove1)
ask1 = read.parse_input("fact: (goodman ?X")
answer1 = self.KB.kb_ask(ask1)
self.assertEqual(len(answer1), 1)
self.assertEqual(str(answer1[0]), "?X : a")
remove1 = read.parse_input("fact: (person a")
self.KB.kb_retract(remove1)
ask1 = read.parse_input("fact: (goodman ?X")
answer1 = self.KB.kb_ask(ask1)
self.assertEqual(len(answer1), 0)
class KBTest(unittest.TestCase):
def setUp(self):
# Assert starter facts
file = 'statements_kb2.txt'
self.data = read.read_tokenize(file)
data = read.read_tokenize(file)
self.KB = KnowledgeBase([], [])
for item in data:
if isinstance(item, Fact) or isinstance(item, Rule):
self.KB.kb_assert(item)
# Tests inferred facts and rules
def test1(self):
f1 = read.parse_input("fact: (isa Mammal Tall)")
print(' Adding', f1)
self.KB.kb_add(f1)
ask1 = read.parse_input("fact: (isa Dog ?X)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertEqual(str(answer[0]), "?X : Mammal")
self.assertEqual(str(answer[1]), "?X : Animal")
self.assertEqual(str(answer[2]), "?X : Tall")
# Remove children of asserted facts when asserted fact is removed
def test2(self):
f1 = read.parse_input("fact: (isa Dog Mammal)")
print(' Retracting', f1)
self.KB.kb_retract(f1)
f2 = read.parse_input("fact: (isa Mammal Tall)")
print(' Adding', f2)
self.KB.kb_add(f2)
ask1 = read.parse_input("fact: (isa Dog ?X)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertEqual(len(answer), 0)
# Fail to remove supported fact
def test3(self):
f1 = read.parse_input("fact: (isa Dog Animal)")
print(' Retracting', f1)
self.KB.kb_retract(f1)
ask1 = read.parse_input("fact: (isa Dog ?X)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertEqual(str(answer[0]), "?X : Mammal")
self.assertEqual(str(answer[1]), "?X : Animal")
# Fail to remove supported fact
def test4(self):
r1 = read.parse_input("rule: ((isa Mammal ?z)) -> (isa Dog ?z))")
print(' Retracting', r1)
self.KB.kb_retract(r1)
f2 = read.parse_input("fact: (isa Mammal Tall)")
print(' Adding', f2)
self.KB.kb_add(f2)
ask1 = read.parse_input("fact: (isa Dog ?X)")
print(' Asking if', ask1)
answer = self.KB.kb_ask(ask1)
self.assertEqual(str(answer[0]), "?X : Mammal")
self.assertEqual(str(answer[1]), "?X : Animal")
self.assertEqual(str(answer[2]), "?X : Tall")
