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
