def manual_constructs(self): p1 = c_const("p1") p2 = c_const("p2") p3 = c_const("p3") parent = c_pred("parent", 2) grandparent = c_pred("grandparent", 2) f1 = parent(p1, p2) f2 = parent(p2, p3) v1 = c_var("X") v2 = c_var("Y") v3 = c_var("Z") cl = grandparent(v1, v3) <= parent(v1, v2) & parent(v2, v3) assert isinstance(p1, Constant) assert isinstance(p2, Constant) assert isinstance(p3, Constant) assert isinstance(parent, Predicate) assert isinstance(grandparent, Predicate) assert isinstance(v1, Variable) assert isinstance(v2, Variable) assert isinstance(v2, Variable) assert isinstance(cl, Clause) assert isinstance(f1, Atom) assert isinstance(f2, Atom)
def graph_connectivity(self): v1 = c_const("v1") v2 = c_const("v2") v3 = c_const("v3") v4 = c_const("v4") edge = c_pred("edge", 2) path = c_pred("path", 2) f1 = edge(v1, v2) f2 = edge(v1, v3) f3 = edge(v2, v4) X = c_var("X") Y = c_var("Y") Z = c_var("Z") cl1 = path(X, Y) <= edge(X, Y) cl2 = path(X, Y) <= path(X, Z) & edge(Z, Y) solver = MuZ() solver.assert_fact(f1) solver.assert_fact(f2) solver.assert_fact(f3) solver.assert_rule(cl1) solver.assert_rule(cl2) # assert solver.has_solution(path(v1, v2)) # assert solver.has_solution(path(v1, v4)) # assert not solver.has_solution(path(v3, v4)) # # assert len(solver.one_solution(path(v1, X))) == 1 # assert len(solver.one_solution(path(X, v4))) == 1 # assert len(solver.one_solution(path(X, Y))) == 2 # # assert len(solver.all_solutions(path(v1, X))) == 3 # assert len(solver.all_solutions(path(X, Y))) == 4 assert solver.has_solution(path(v1, v2)) assert solver.has_solution(path(v1, v4)) assert not solver.has_solution(path(v3, v4)) assert len(solver.query(path(v1, X), max_solutions=1)[0]) == 1 assert len(solver.query(path(X, v4), max_solutions=1)[0]) == 1 assert len(solver.query(path(X, Y), max_solutions=1)[0]) == 2 assert len(solver.query(path(v1, X))) == 3 assert len(solver.query(path(X, Y))) == 4
def variables(self, y, l): number = min(26, y) self._encodingvariables = [] self._variablesindices = {} index = 0 for code in range(ord('A'), ord('A') + number): self._variablesindices[c_var(chr(code))] = index index = index + l for i in range(0, l): self._encodingvariables.append(0)
def all_possible_atoms(self) -> Sequence[Atom]: """ Creates all possible argument configurations for the atom """ head_variables = [c_var(chr(x)) for x in range(ord("A"), ord("Z"))][:self._arity] if self._arity is not None: return [ Atom(self.new(), list(x)) for x in product(head_variables, repeat=self._arity) ] else: combos = [] for i in range(self._min_arity, self._max_arity): combos += [ Atom(self.new(arity=i), list(x)) for x in product(head_variables, repeat=i) ] return combos
def new_variable( existing_variables: typing.Set[Variable], type: Type = None ) -> Variable: existing_variable_names = {x.get_name() for x in existing_variables} if len(existing_variables) < 27: potential_names = [ chr(x) for x in range(ord("A"), ord("Z") + 1) if chr(x) not in existing_variable_names ] else: potential_names = [ f"{chr(x)}{chr(y)}" for x in range(ord("A"), ord("Z") + 1) for y in range(ord("A"), ord("Z") + 1) if f"{chr(x)}{chr(y)}" not in existing_variable_names ] return c_var(potential_names[0], type)
from loreleai.language.lp import c_functor, c_pred, c_var, List from loreleai.reasoning.lp.prolog import GNUProlog pl = GNUProlog() p = c_pred("p", 2) f = c_functor("t", 3) f1 = p("a", "b") pl.assertz(f1) X = c_var("X") Y = c_var("Y") query = p(X, Y) r = pl.has_solution(query) print("has solution", r) rv = pl.query(query) print("all solutions", rv) f2 = p("a", "c") pl.assertz(f2) rv = pl.query(query) print("all solutions after adding f2", rv) func1 = f(1, 2, 3) f3 = p(func1, "b")
not_letter = c_pred("not_letter", 1) is_number = c_pred("is_number", 1) not_number = c_pred("not_number", 1) skip1 = c_pred("skip1", 2) copy1 = c_pred("copy1", 2) write1 = c_pred("write1", 3) copyskip1 = c_pred("copyskip1", 2) mk_uppercase = c_pred("mk_uppercase", 2) mk_lowercase = c_pred("mk_lowercase", 2) convert_case = c_pred("convert_case", 2) is_number_aux = c_pred("is_number_aux", 1) s = c_pred("s", 2) b45 = c_pred("b45", 2) is_uppercase = c_pred("is_uppercase", 1) # define the Variables H = c_var("H") Ta = c_var("Ta") Tb = c_var("Tb") A = c_var("A") B = c_var("B") C = c_var("C") D = c_var("D") E = c_var("E") H1 = c_var("H1") H2 = c_var("H2") Z = c_var("Z") O = c_var("O") N = c_var("N") # create clauses head = Atom(not_space, [A]) body = Atom(is_space, [A])
def learn_text(): """ We describe piece of text spanning multiple lines: "node A red <newline> node B green <newline> node C blue <newline>" using the next\2, linestart\2, lineend\2, tokenlength\2 predicates """ token = c_type("token") num = c_type("num") next = c_pred("next", 2, ("token", "token")) linestart = c_pred("linestart", 2, ("token", "token")) lineend = c_pred("lineend", 2, ("token", "token")) tokenlength = c_pred("tokenlength", 2, ("token", "num")) n1 = c_const("n1", num) n3 = c_const("n3", num) n4 = c_const("n4", num) n5 = c_const("n5", num) node1 = c_const("node1", token) node2 = c_const("node2", token) node3 = c_const("node3", token) red = c_const("red", token) green = c_const("green", token) blue = c_const("blue", token) a_c = c_const("a_c", token) b_c = c_const("b_c", token) c_c = c_const("c_c", token) start = c_const("c_START", token) end = c_const("c_END", token) bk = Knowledge(next(start, node1), next(node1, a_c), next(a_c, red), next(red, node2), next(node2, green), next(green, b_c), next(b_c, node3), next(node3, c_c), next(c_c, blue), next(blue, end), tokenlength(node1, n4), tokenlength(node2, n4), tokenlength(node3, n4), tokenlength(a_c, n1), tokenlength(b_c, n1), tokenlength(c_c, n1), tokenlength(red, n3), tokenlength(green, n5), tokenlength(blue, n4), linestart(node1, node1), linestart(a_c, node1), linestart(red, node1), linestart(node2, node2), linestart(b_c, node2), linestart(green, node2), linestart(node3, node3), linestart(c_c, node3), linestart(blue, node3), lineend(node1, a_c), lineend(a_c, red), lineend(node2, red), lineend(b_c, green), lineend(node3, blue), lineend(c_c, blue), lineend(red, red), lineend(green, green), lineend(blue, blue)) solver = SWIProlog() eval_fn1 = Coverage(return_upperbound=True) learner = Aleph(solver, eval_fn1, max_body_literals=3, do_print=False) # 1. Consider the hypothesis: f1(word) :- word is the second word on a line if True: f1 = c_pred("f1", 1, [token]) neg = {f1(x) for x in [node1, node2, node3, blue, green, red]} pos = {f1(x) for x in [a_c, b_c, c_c]} task = Task(positive_examples=pos, negative_examples=neg) res = learner.learn(task, bk, None) print(res) # 2. Consider the hypothesis: f2(word) :- word is the first word on a line if True: f2 = c_pred("f2", 1, [token]) neg = {f1(x) for x in [a_c, b_c, c_c, blue, green, red]} pos = {f1(x) for x in [node1, node2, node3]} task2 = Task(positive_examples=pos, negative_examples=neg) res = learner.learn(task2, bk, None) print(res) # 3. Assume we have learned the predicate node(X) before (A, B and C and nodes). # We want to learn f3(Node,X) :- X is the next token after Node if True: node = c_pred("node", 1, [token]) color = c_pred("color", 1, [token]) nodecolor = c_pred("nodecolor", 2, [token, token]) a = c_var("A", token) b = c_var("B", token) bk_old = bk.get_all() bk = Knowledge(*bk_old, node(a_c), node(b_c), node(c_c), node(a_c), node(b_c), node(c_c), color(red), color(green), color(blue)) pos = { nodecolor(a_c, red), nodecolor(b_c, green), nodecolor(c_c, blue) } neg = set() neg = { nodecolor(node1, red), nodecolor(node2, red), nodecolor(node3, red), nodecolor(node1, blue), nodecolor(node2, blue), nodecolor(node2, blue), nodecolor(node1, green), nodecolor(node2, green), nodecolor(node3, green), nodecolor(a_c, green), nodecolor(a_c, blue), nodecolor(b_c, blue), nodecolor(b_c, red), nodecolor(c_c, red), nodecolor(c_c, green) } task3 = Task(positive_examples=pos, negative_examples=neg) # prog = learner.learn(task3,bk,None,initial_clause=Body(node(a),color(b))) result = learner.learn(task3, bk, None, initial_clause=Body(node(a), color(b)), minimum_freq=3) print(result)
not_letter = c_pred("not_letter", 1) is_number = c_pred("is_number", 1) not_number = c_pred("not_number", 1) skip1 = c_pred("skip1", 2) copy1 = c_pred("copy1", 2) write1 = c_pred("write1", 3) copyskip1 = c_pred("copyskip1", 2) mk_uppercase = c_pred("mk_uppercase", 2) mk_lowercase = c_pred("mk_lowercase", 2) convert_case = c_pred("convert_case", 2) is_number_aux = c_pred("is_number_aux", 1) s = c_pred("s", 2) b45 = c_pred("b45", 2) is_uppercase = c_pred("is_uppercase", 1) # define the Variables H = c_var("H") Ta = c_var("Ta") Tb = c_var("Tb") A = c_var("A") B = c_var("B") H1 = c_var("H1") H2 = c_var("H2") Z = c_var("Z") O = c_var("O") N = c_var("N") # create clauses head = Atom(not_space, [A]) body = Atom(is_space, [A]) clause1 = Clause(head, Body(Not(body))) head = Atom(is_uppercase, [Structure(s, [Pair(H, Z), O])]) body = Atom(is_uppercase_aux, [H])
def simple_grandparent(self): p1 = c_const("p1") p2 = c_const("p2") p3 = c_const("p3") parent = c_pred("parent", 2) grandparent = c_pred("grandparent", 2) f1 = parent(p1, p2) f2 = parent(p2, p3) v1 = c_var("X") v2 = c_var("Y") v3 = c_var("Z") cl = (grandparent(v1, v3) <= parent(v1, v2) & parent(v2, v3)) solver = MuZ() solver.assert_fact(f1) solver.assert_fact(f2) solver.assert_rule(cl) # assert solver.has_solution(parent(v1, v2)) # assert not solver.has_solution(parent(v1, v1)) # assert len(solver.all_solutions(parent(v1, v2))) == 2 # assert len(solver.all_solutions(parent(p1, v1))) == 1 # assert solver.has_solution(parent(p1, p2)) # assert not solver.has_solution(parent(p2, p1)) # assert len(solver.one_solution(parent(p1, v1))) == 1 # # assert solver.has_solution(grandparent(v1, v2)) # assert solver.has_solution(grandparent(p1, v1)) # assert len(solver.one_solution(grandparent(p1, v1))) == 1 # assert solver.has_solution(grandparent(p1, p3)) # assert not solver.has_solution(grandparent(p2, v1)) # assert len(solver.one_solution(grandparent(p1, v1))) == 1 # ans = solver.one_solution(grandparent(p1, v1)) # assert ans[v1] == p3 # ans = solver.one_solution(grandparent(v1, v2)) # assert ans[v1] == p1 and ans[v2] == p3 # # assert solver.has_solution(cl) # ans = solver.one_solution(cl) # assert ans[v1] == p1 and ans[v3] == p3 # assert len(solver.all_solutions(cl)) == 1 assert solver.has_solution(parent(v1, v2)) assert not solver.has_solution(parent(v1, v1)) assert len(solver.query(parent(v1, v2))) == 2 assert len(solver.query(parent(p1, v1))) == 1 assert solver.has_solution(parent(p1, p2)) assert not solver.has_solution(parent(p2, p1)) assert len(solver.query(parent(p1, v1), max_solutions=1)) == 1 assert solver.has_solution(grandparent(v1, v2)) assert solver.has_solution(grandparent(p1, v1)) assert len(solver.query(grandparent(p1, v1), max_solutions=1)) == 1 assert solver.has_solution(grandparent(p1, p3)) assert not solver.has_solution(grandparent(p2, v1)) assert len(solver.query(grandparent(p1, v1), max_solutions=1)) == 1 ans = solver.query(grandparent(p1, v1), max_solutions=1)[0] assert ans[v1] == p3 ans = solver.query(grandparent(v1, v2), max_solutions=1)[0] assert ans[v1] == p1 and ans[v2] == p3 assert solver.has_solution(*cl.get_literals()) ans = solver.query(*cl.get_literals(), max_solutions=1)[0] assert ans[v1] == p1 and ans[v3] == p3 assert len(solver.query(*cl.get_literals())) == 1
from filereaders.taskreader import readPositiveOfType from loreleai.language.lp import c_pred, c_functor, c_var, List from loreleai.reasoning.lp.prolog import SWIProlog # Test for the given background knowledge pl = SWIProlog() pl.consult("../inputfiles/StringTransformations_BackgroundKnowledge.pl") # Load all test tasks in a dictionary. The key is the id of a task and the value is a set of all tasks test = readPositiveOfType("../inputfiles/StringTransformationProblems", "test_task") # Basic variables test_task = c_pred("test_task", 1) A = c_var("A") B = c_var("B") # one of the examples: test_task(s(['o','x','1',' ','3','c','p'],['O','X','1','3','C','P'])) # Everything in this set starts with lowercase 'o' in the input and uppercase 'O' in output, like the example above # One example in this set is used to test if it's covered by the clauses below. tex = test.get("b113").pop() print(tex) # We test whether the example starts without a space, this should be true not_space = c_pred("not_space", 1) # not_space(A):- \+is_space(A). cl = test_task(A) <= not_space(A) pl.asserta(cl) sol = pl.has_solution(tex) # Returns true, good print(sol) pl.retract(cl)