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")