def test_final_2_3():
s = {Variable(("Y")): Number("0"), Variable("X"): Variable(("Y"))}
r = Rule((Function(
"p", [Variable("X"), Variable("Y"),
Atom("a")])), RuleBody([]))
r_ = Rule(
(Function("p", [Variable("Y"),
Number("0"), Atom("a")])), RuleBody([]))
assert (interpreter.substitute_in_clause(s, r) == r_)
def test_final_2_4():
s = {Variable(("Y")): Number("0"), Variable("X"): Variable(("Y"))}
p = Function("p", [Variable("X"), Variable(("Y")), Atom(("a"))])
q = Function("q", [Atom(("a")), Atom(("b")), Atom(("a"))])
p_ = Function("p", [Variable(("Y")), Number("0"), Atom(("a"))])
q_ = Function("q", [Atom(("a")), Atom(("b")), Atom(("a"))])
r = Rule(p, RuleBody([q]))
r_ = Rule(p_, RuleBody([q_]))
assert (interpreter.substitute_in_clause(s, r) == r_)
def test_substitute_in_clause(self):
s = {Variable("Y"): Number(0), Variable("X"): Variable("Y")}
p = Function("p", [Variable("X"), Variable("Y"), Atom("a")])
q = Function("q", [Atom("a"), Atom("b"), Atom("a")])
p_ = Function("p", [Variable("Y"), Number(0), Atom("a")])
q_ = Function("q", [Atom("a"), Atom("b"), Atom("a")])
r = Rule(p, [q])
r_ = Rule(p_, [q_])
#assert
(self.substitute_in_clause(s, r) == r_)
def test_variables_of_clause(self):
c = Rule(
Function("p",
[Variable("X"), Variable("Y"),
Atom("a")]),
RuleBody([Function(
"q", [Atom("a"), Atom("b"), Atom("a")])]))
#assert
(self.variables_of_clause(c) == set([Variable("X"), Variable("Y")]))
def request(self, body):
return Rule(None, body)
def rule(self, predicate, body):
return Rule(predicate, body)
def assertion(self, predicate):
return Rule(predicate, RuleBody([]))
def test_final_1_4():
h = Function("p", [Variable("X"), Variable("Y"), Atom("a")])
b = [Function("q", [Atom("a"), Atom("b"), Atom("a")])]
r = Rule(h, RuleBody(b))
assert (interpreter.variables_of_clause(r) == set(
[Variable("X"), Variable("Y")]))
def test_final_1_3():
r = Rule((Function(
"p", [Variable("X"), Variable("Y"),
Atom("a")])), RuleBody([]))
assert ((interpreter.variables_of_clause(r) == set(
[Variable("X"), Variable("Y")])))
def test_final_3_9():
t1 = Function("f", [Variable("X"), Variable("Y"), Variable("Y")])
t2 = Function("f", [Variable("Y"), Variable("Z"), Atom("a")])
u = {
Variable("X"): Atom("a"),
Variable("Y"): Atom("a"),
Variable("Z"): Atom("a")
}
#print("9")
assert (interpreter.unify(t1, t2) == u)
def list2str(l):
return ('(' + (',' + ' ').join(list(map(str, l))) + ')')
# Test on a simple program
psimple = [Rule(Function("f", [Atom("a"), Atom("b")]), RuleBody([]))]
def test_final_4_1():
print(
"\n\n################################################################"
)
print(
"###### Testing the non-deterministic abstract interpreter ######")
print(
"################################################################")
print(f"Program: {list2str(psimple)}")
g = [Function("f", [Atom("a"), Atom("b")])]
print(f"Goal: {list2str(g)}")
g_ = interpreter.nondet_query(psimple, g)
assert (g_ == [Function("f", [Atom("a"), Atom("b")])])
print(f"Solution: {list2str(g_)}")