def testImplicationLaw(self): il = ImplicationLaw() s = logicParse('p -> q') t = logicParse('p v ~q', s.propMap) u = logicParse("a&(~p v ~q)", t.propMap) assert il.getSuccessors(s, 0) == logicParse('(~p v q)',u.propMap) assert il.getSuccessors(t, 0) == logicParse('q -> p',u.propMap)
def testPropositionEquivalence(self): p = logicParse('p') q = logicParse('q',p.propMap) p2 = logicParse('p',q.propMap) assert p == p2 assert q != p2
def testDeMorgan(self): s = logicParse('(p & q) & m') t = logicParse('(~p v ~q) & m ') dm= DeMorgans() print dm.getSuccessors(s, 1) print dm.getSuccessors(t, 1) # assert dm.getSuccessors(s, 1) == logicParse('(~(~p v ~q) & m)') assert dm.getSuccessors(t, 1) == logicParse('(~(p & q) & m)')
def testNegLaw(self): neg = Negation() s = logicParse('p & ~p') #contradiction t = logicParse('p v ~p') #tautology assert neg.getSuccessors(s, 0) == logicParse('False') assert neg.getSuccessors(t, 0) == logicParse('True')
def testCommute(self): com = Commutativity() s = logicParse('p v (q v r)') goal = logicParse('p v (r v q)',s.propMap) assert com.getSuccessors(s, 2, goal.cohash()) == goal goal2 = logicParse('(q v r) v p', s.propMap) suc = com.getSuccessors(s, 0,goal2.cohash()) assert suc == goal2
def testNode(self): start = logicParse("~((p -> q))") start.action = None start.cost = 0 goal = logicParse("p & ~q") n = Node(start, None) s = n.successors(rules, goal) assert s[0].state == logicParse("~(~p v q)")
def testAbsorption(self): answer = logicParse("p") s = logicParse('p & (p v q)') t = logicParse('(p v q) & p') u = logicParse('p v (p & q)') v = logicParse('(p & q) v p') absorb = Absorption() assert absorb.getSuccessors(s, 0) == answer assert absorb.getSuccessors(t, 0) == answer assert absorb.getSuccessors(u, 0) == answer assert absorb.getSuccessors(v, 0) == answer
def testCommute(self): start = logicParse(" (~((p & p) -> q))") start.action = "Beginning Premise" start.cost = 0 goal = logicParse("~q & p", start.propMap) steps = search(start, goal, rules) print "\nDemonstrate that", start, "is logically equivalent to", goal print "\nCost:\tRule:\t\t\t\tStatement:" for s in steps: print s.cost, "\t", s.action, "\t\t", s.state print "\nTherefore, ", start, " = ", goal, "."
def testNotEquivalentSearch(self): # this one will get stuck forever until we figure out how to know when to quit print "impossible" start = logicParse("p -> q") start.action = "Beginning Premise" start.cost = 0 goal = logicParse("q -> p", start.propMap) steps = search(start, goal, rules, True) print "\nCost:\tRule:\t\t\t\tStatement:" assert steps == False
def testSearchHW1noCache(self): print "\n\n******Hard Problem, no cache******" # (p -> q) & (q -> p) start # (~p v q) & (~q v p) implication # ((~p v q) & ~q)&((~p v q) & p) distribution # ((~p & ~q) v (q & ~q)) v ((p & ~p) v (q&p)) distribution # (~p & ~q) v (q&p) ??? start = logicParse("(p -> q) & (q -> p)") goal = logicParse("(p & q)v(~p & ~q)", start.propMap) steps = search(start, goal, rules) print "\nDemonstrate that", start, "is logically equivalent to", goal print "\nCost:\tEst%Complete\tRule:\t\t\t\tStatement:" for s in steps: print s.cost, "\t", distance(str(s.state), str(goal)), "\t\t", s.action, "\t\t", s.state.mml() print "\nTherefore, ", start, " = ", goal, "."
def testSearch2(self): start = logicParse("~(b v c) & (~b & ~c)") start.action = "Beginning Premise" start.cost = 0 goal = logicParse("~(b v c)", start.propMap) steps = search(start, goal, rules) print "\nDemonstrate that", start, "is logically equivalent to", goal print "\nCost:\tRule:\t\t\t\tStatement:" for s in steps: print s.cost, "\t", round( float(s.cost) / (s.cost + distance(str(s.state), str(goal))), 2 ), "\t\t", s.action, "\t\t", s.state print "\nTherefore, ", start, " = ", goal, "."
def testTreeIndexing(self): s = logicParse("q & (~(r -> s) | t)") assert s[0] == s assert str(s[1]) == "q" assert str(s[2]) == "(~(r > s) v t)" assert str(s[11]) == "(r > s)"
def testSearch4(self): # this one needs truth constants to work. start = logicParse("~(p v (~p & q))") start.action = "Beginning Premise" start.cost = 0 goal = logicParse("~p & ~q", start.propMap) goal.action = "Goal" steps = search(start, goal, rules) print "\nDemonstrate that", start, "is logically equivalent to", goal print "\nCost:\tRule:\t\t\t\tStatement:" for s in steps: print s.cost, "\t", round( float(s.cost) / (s.cost + distance(str(s.state), str(goal))), 2 ), "\t\t", s.action, "\t\t", s.state print "\nTherefore, ", start, " = ", goal, "."
def testIdentity(self): ident = Identity() s = logicParse('a -> (p v F)') t = logicParse('a -> (F v T)') u = logicParse('True & p') v = logicParse('p & T') assert ident.getSuccessors(s, 2) == logicParse('a -> p') assert ident.getSuccessors(t, 2) == logicParse('a -> True') assert ident.getSuccessors(u, 0) == logicParse('p') assert ident.getSuccessors(v, 0) == logicParse('p')
def testDomination(self): dom = Domination() s = logicParse('a -> (p & F)') t = logicParse('a -> (F & T)') u = logicParse('True v p') v = logicParse('T v F') assert dom.getSuccessors(s, 2) == logicParse('a -> False') assert dom.getSuccessors(t, 2) == logicParse('a -> False') assert dom.getSuccessors(u, 0) == logicParse('True') assert dom.getSuccessors(v, 0) == logicParse('True')
def testAssoc(self): # single successor cases s = logicParse("(a & b) & c") t = logicParse("a or (b or c)") assoc = Associativity() assert assoc.getSuccessors(s, 0) == logicParse("a & (b &c)") assert assoc.getSuccessors(t, 0) == logicParse("(a or b) or c)") #multi successor u = logicParse("(a or b) or (c or d)") us1 = logicParse("a or (b or (c or d))") us2 = logicParse("((a or b) or c) or d") assert assoc.getSuccessors(u, 0) == [us1, us2]
def testSearch3H(self): print "\n\n******Prove 3H******" start = "~(p -> q)" goal = "p & ~q" steps = findDerivation(start, goal, rules) print "\nDemonstrate that", start, "is logically equivalent to", goal print "\nCost:\tRule:\t\t\t\tStatement:" for s in steps: print s.cost, "\t", round( float(s.cost) / (s.cost + distance(str(s.state), str(logicParse(goal)))), 2 ), "\t\t", s.action, "\t\t", s.state print "\nTherefore, ", start, " = ", goal, "."
def testEquality(self): ab = logicParse("a and b") ba = logicParse("a and b", ab.propMap) assert ab == ba aib = logicParse("a implies b") bia = logicParse("b implies a", aib.propMap) assert aib != bia c1 = logicParse("(a & b) -> c") c2 = logicParse("(b & a) -> c",c1.propMap) assert c1 != c2
def testDist(self): s = logicParse("p & (q or r)") t = logicParse("(q & r) v p") dist = Distributivity() ssucs = logicParse('(p & q) v (p & r)',s.propMap) tsucs = logicParse('(p v q) & (p v r)',t.propMap) assert dist.getSuccessors(s, 0) == ssucs assert dist.getSuccessors(t, 0) == tsucs m = logicParse("(p & (q or r)) & m") mtarget = logicParse("((p & q) v (p & r)) & m") assert dist.getSuccessors(m, 1) == mtarget
def testNegatedChildTree(self): s = logicParse("(a & b) -> ~(a & b)") n1 = s.negatedChildTree(1) n2 = s.negatedChildTree(2) assert n1 == s.childTree(2) assert n2 == s.childTree(1)
def testParseHash(self): s = '(a implies q) & (q -> a)' g = '(~a & ~q) v (q & a)' startParse = logicParse(s) goalParse = logicParse(g, startParse.propMap) assert hash((startParse,goalParse))== -1223974109378650937
def searchHW1noCacheNoCommute(self): start = logicParse('(p -> q) & (q -> p)') goal = logicParse('(~p & ~q) v (q &p)',start.propMap) rules = [Negation(),Identity(),Domination(),Idempotence(),Associativity(),Exportation(),Distributivity(),Absorption(),DoubleNegation(),DeMorgans(),ImplicationLaw()] steps = search(start,goal,rules)
def testGraft(self): graftee = logicParse("a implies (b implies c)") graft = logicParse("~b or c",graftee.propMap) target = logicParse("a -> (~b or c)",graftee.propMap) new = graftee.graft(2, graft) assert new == target
def testReIndex(self): s = logicParse("q & (~(r -> s) | t)") assert set(s.d.keys()) == set([0, 1, 2, 5, 6, 11, 23, 24]) s.reIndex(0, 1) assert set(s.d.keys()) == set([1, 4, 9, 3, 19, 39, 40, 10])
def testNegationEquality(self): notp = logicParse("!p") othernotp = logicParse("~p") assert notp == othernotp
''' Created on Mar 16, 2013 @author: colinwinslow ''' from model.InputReader import logicParse a = logicParse("((w v a ))v true") b = logicParse("a -") c = logicParse("a ->") d = logicParse("a -> b") print a print b print c print d
def testNegation(self): notp = logicParse("~p") assert str(notp) == "~p"
def testIdempotence(self): s = logicParse("a & (b or b)") idem = Idempotence() assert logicParse("a & b") == idem.getSuccessors(s, 2) assert idem.getSuccessors(s, 1) == None assert idem.getSuccessors(s, 0) == None
def testExportation(self): s = logicParse("(a -> b) -> c") t = logicParse("a -> (b -> c)") ex = Exportation() assert ex.getSuccessors(s, 0) == t assert ex.getSuccessors(t, 0) == s
def testDN(self): s = logicParse('~~p') answer = logicParse("p") dn = DoubleNegation() assert dn.getSuccessors(s, 0)==answer