def setUp(self):
self.kb = KnowledgeBase()
class TestCore(TestCase):
def setUp(self):
self.kb = KnowledgeBase()
def testEquals(self):
block = self.kb.root
literal = self.kb.addEntity(Literal(10))
statement = Statement("foo", {"x": literal})
self.kb.addStatement(block, statement)
literal2 = self.kb.addEntity(Literal(10))
statement2 = Statement("foo", {"x": literal2})
self.kb.addStatement(block, statement)
self.assertTrue(statement.equals(self.kb, statement2))
def testNotEquals(self):
block = self.kb.root
literal = self.kb.addEntity(Literal(10))
statement = Statement("foo", {"x": literal})
self.kb.addStatement(block, statement)
self.assertFalse(self.kb[literal].equals(self.kb, statement))
literal2 = self.kb.addEntity(Literal(10))
statement2 = Statement("foo", {"x": literal2, "y": literal2})
self.kb.addStatement(block, statement)
self.assertFalse(statement.equals(self.kb, statement2))
literal3 = self.kb.addEntity(Literal(5))
statement3 = Statement("foo", {"x": literal3})
self.kb.addStatement(block, statement)
self.assertFalse(statement.equals(self.kb, statement3))
def testSubstitute(self):
# foo(a: x, b: x)[x -> 10] == foo(a: 10, b: 10)
block = self.kb.root
variable = Variable("x")
statement = Statement("foo", {"a": variable, "b": variable})
statementID = self.kb.addStatement(block, statement)
literal = self.kb.addEntity(Literal(10))
statement2 = statement.substitute(statementID, self.kb, {"x": literal})
statement3 = self.kb.addStatement(block, Statement("foo", {"a": literal, "b": literal}))
self.assertTrue(self.kb[statement2].equals(self.kb, self.kb[statement3]))
def testUnify(self):
# foo(l: bar(a: x), r: y) ~~ foo(l: z, r:z) == { y -> bar(a: x), z -> bar(a: x) }
block = self.kb.root
x = Variable("x")
y = Variable("y")
z = Variable("z")
statement = Statement("bar", {"a": x})
statementID = self.kb.addEntity(statement)
statement2 = Statement("foo", {"l": statementID, "r": y})
statement2ID = self.kb.addStatement(block, statement2)
statement3 = Statement("foo", {"l": z, "r": z})
statement3ID = self.kb.addStatement(block, statement3)
self.assertTrue(statement2.unify(self.kb, statement3ID) == {"y": statementID, "z": statementID})
def testQuery(self):
block = self.kb.root
x = Variable("x")
literal = self.kb.addEntity(Literal(10))
literal2 = self.kb.addEntity(Literal(15))
statement = Statement("foo", {"a": literal})
statement2 = Statement("foo", {"a": literal2})
statementID = self.kb.addStatement(block, statement)
statement2ID = self.kb.addStatement(block, statement2)
pattern = Statement("foo", {"a": x})
result = [r for r in self.kb.query(pattern)]
self.assertTrue(len(result) == 2)
self.assertTrue(result[0][0] == statementID)
self.assertTrue(result[0][1]['x'] == literal)
self.assertTrue(result[1][0] == statement2ID)
self.assertTrue(result[1][1]['x'] == literal2)
def testPatternInference(self):
# Inference rule: foo(a: x), bar(b: x) -> conclusion()
# Knowledge Base:
# foo(a: 10) #1
# bar(b: 15) #2
# bar(b: 10) #3
# Expected result:
# env: {x -> 10}
# dependencies: [#1, #3]
# conclusion: conclusion()
block = self.kb.root
x = Variable("x")
literal = self.kb.addEntity(Literal(10))
literal2 = self.kb.addEntity(Literal(15))
statement = Statement("foo", {"a": literal})
statement2 = Statement("bar", {"b": literal2})
statement3 = Statement("bar", {"b": literal})
statementID = self.kb.addStatement(block, statement)
statement2ID = self.kb.addStatement(block, statement2)
statement3ID = self.kb.addStatement(block, statement3)
pattern = Statement("foo", {"a": x})
pattern2 = Statement("bar", {"b": x})
conclusion = Statement("conclusion", {})
patternID = self.kb.addEntity(pattern)
pattern2ID = self.kb.addEntity(pattern2)
conclusionID = self.kb.addEntity(conclusion)
irule = InferenceRule(["x"], conclusionID, [patternID, pattern2ID])
results = [result for result in irule.getInferences(self.kb)]
self.assertTrue(results == [({'x': literal}, [statementID, statement3ID], conclusionID)])
def testQuantor(self):
block = self.kb.root
quantorBlockID = self.kb.addBlock()
statement = Statement("foo", {"1": Variable("x"), "2": Variable("y")})
self.kb.addStatement(quantorBlockID, statement)
quantor = Quantor("forall", {}, ["x"], quantorBlockID)
statementID = self.kb.addStatement(block, quantor)
ten = self.kb.addEntity(Literal(10))
substitutedID = quantor.substitute(statementID, self.kb, {"x": ten, "y": ten})
self.assertTrue(self.kb[self.kb[self.kb[substitutedID].block].statements[0]].parameters["1"].equals(Variable("x")))
self.assertTrue(self.kb[self.kb[self.kb[self.kb[substitutedID].block].statements[0]].parameters["2"]].equals(self.kb, Literal(10)))
