def isFactInKB(factPredicate, factArgs, factQuery, prolog, predicateDict): sig = Signature.getsignature(str(factPredicate), len(factArgs)) isBuiltin = prolog.get_builtin(sig) assert (not isBuiltin), 'we should have already checked this' factInKB = False query = '{0}({1}).'.format( factPredicate, ','.join(['X_{0}'.format(i) for i in range(len(factArgs))])) if prologPath == '/testnet' or prologPath == '/proofspyrolog': proof = collect_all(prolog, query, [], [], [], []) elif prologPath == '/spyrolog': proof = collect_all(prolog, query, [], [], []) for vGrounding in proof: groundings = vGrounding[0] args = set() for variable, grounding in groundings.iteritems(): if hasattr(grounding, 'name'): args.add(grounding.name()) elif hasattr(grounding, 'num'): args.add(grounding.num) else: print 'dir:', dir(grounding) raise AttributeError if not set(factArgs).difference(args): factInKB = True break return factInKB
def test_fail(): e = get_engine(""" g(a). f(X) :- g(X), fail. f(a). """) heaps = collect_all(e, "f(X).") assert len(heaps) == 1
def test_atom_concat(): assert_true("atom_concat(ab, cdef, abcdef).") assert_true("atom_concat(ab, cdef, X), X = abcdef.") assert_true("atom_concat(ab, X, abcdef), X = cdef.") assert_true("atom_concat(X, cdef, abcdef), X = ab.") assert_true("atom_concat(1, Y, '1def'), Y = def.") heaps = collect_all(Engine(), "atom_concat(X, Y, abcd), atom(X), atom(Y).") assert len(heaps) == 5
def test_call_cut(): e = get_engine(""" f(X) :- call(X). f(!). """) heaps = collect_all(e, "f(!).") assert len(heaps) == 2 assert_true("call(((X = a; X = b), !, X = b)); X = c.") assert_false("(((X = a; X = b), !, X = b)); X = c.")
def test_between(): assert_true("between(12, 15, 12).") assert_true("between(-5, 15, 0).") assert_false("between(12, 15, 6).") assert_false("between(12, 15, 16).") heaps = collect_all(Engine(), "between(1, 4, X).") assert len(heaps) == 4 assert heaps[0]['X'].num == 1 assert heaps[-1]['X'].num == 4
def test_and_long(): e = get_engine(""" f(x). f(y). f(z). g(a). g(b). g(c). h(d). h(e). h(f). f(X, Y, Z) :- f(X), g(Y), h(Z). """) heaps = collect_all(e, "f(X, Y, Z).") assert len(heaps) == 27
def test_cut2(): e = get_engine(""" g(a). g(b). h(a, x). h(a, y). f(X, Y) :- g(X), !, !, !, !, !, h(X, Y). """) heaps = collect_all(e, "f(X, Y).") assert len(heaps) == 2
def test_atom_concat(): assert_true("atom_concat(ab, cdef, abcdef).") assert_true("atom_concat(ab, cdef, X), X = abcdef.") assert_true("atom_concat(ab, X, abcdef), X = cdef.") assert_true("atom_concat(X, cdef, abcdef), X = ab.") assert_true("atom_concat(1, Y, '1def'), Y = def.") heaps = collect_all( Engine(), "atom_concat(X, Y, abcd), atom(X), atom(Y).") assert len(heaps) == 5
def test_indexing2(): e = get_engine(""" mother(o, j). mother(o, m). mother(o, b). sibling(X, Y) :- mother(Z, X), mother(Z, Y). """) heaps = collect_all(e, "sibling(m, X).") assert len(heaps) == 3
def test_collect_all(): e = get_engine(""" g(a). g(b). g(c). """) heaps = collect_all(e, "g(X).") assert len(heaps) == 3 assert heaps[0]['X'].name() == "a" assert heaps[1]['X'].name() == "b" assert heaps[2]['X'].name() == "c"
def test_collect_all(): e = get_engine(""" g(a). g(b). g(c). """) heaps = collect_all(e, "g(X).") assert len(heaps) == 3 assert heaps[0]['X'].name()== "a" assert heaps[1]['X'].name()== "b" assert heaps[2]['X'].name()== "c"
def test_rule_with_cut_calling_rule_with_cut(): e = get_engine(""" e(a). e(b). f(b) :- e(_), !. f(c). g(X) :- f(X), !. g(a). """) heaps = collect_all(e, "g(X).") assert len(heaps) == 1
def test_library_directory(): e = Engine() m = e.modulewrapper assert m.libs == [] libs = collect_all(e, "library_directory(X).") assert len(libs) == 0 tempdir1 = "__tempdir1__" tempdir2 = "__tempdir2__" create_dir(tempdir1) create_dir(tempdir2) try: assert_true("add_library_dir('%s')." % tempdir1, e) assert_true("add_library_dir('%s')." % tempdir2, e) libs = collect_all(e, "library_directory(X).") assert len(libs) == 2 assert len(m.libs) == 2 finally: delete_dir(tempdir1) delete_dir(tempdir2)
def test_or_backtrack(): e = get_engine(""" a(a). b(b). g(a, b). g(a, a). f(X, Y, Z) :- (g(X, Z); g(X, Z); g(Z, Y)), a(Z). """) t, vars = get_query_and_vars("f(a, b, Z).") e.run_query_in_current(t) assert vars['Z'].dereference(None).name()== "a" f = collect_all(e, "X = 1; X = 2.") assert len(f) == 2
def test_or_backtrack(): e = get_engine(""" a(a). b(b). g(a, b). g(a, a). f(X, Y, Z) :- (g(X, Z); g(X, Z); g(Z, Y)), a(Z). """) t, vars = get_query_and_vars("f(a, b, Z).") e.run_query_in_current(t) assert vars['Z'].dereference(None).name() == "a" f = collect_all(e, "X = 1; X = 2.") assert len(f) == 2
def test_cut1(): e = get_engine(""" g(a). g(b). a(a). b(b). f(X) :- g(X),!,b(X). f(x). f(y). """) heaps = collect_all(e, "f(X).") assert len(heaps) == 0 assert_true("!.")
def test_or(): similarity = Similarity(0) similarity.set_score('believes_in', 'asserts', 0.2) similarity.set_score('free_will', 'free_goodies', 0.8) similarity.set_score('asserts', 'believes_in', 1.0) e = get_engine(""" believes_in(alice, free_will). """, similarity=similarity) # result = assert_true("believes_in(X, free_will).", e) # print result result = collect_all(e, "asserts(alice, free_goodies).") print result
def test_parser_access(): assert_true("current_op(200, xfx, **).") f = collect_all(Engine(), "current_op(200, Form, X).") assert len(f) == 2 e = get_engine(""" foo(a, b). """) assert_true("op(450, xfy, foo).", e) assert_true("a foo b.", e) assert_true("op(0, xfy, foo).", e) # XXX really a ParseError py.test.raises(Exception, assert_false, "a foo b.", e) # change precedence of + for funny results :-) assert_true("14 is 2 + 3 * 4.", e) assert_true("op(350, xfy, +).", e) assert_true("20 is 2 + 3 * 4.", e) assert_true("op(500, xfy, +).", e)
def test_assert_logical_update_view(): e = get_engine(""" g(a). g(c) :- assertz(g(d)). g(b). """) heaps = collect_all(e, "g(X).") assert len(heaps) == 3 e = get_engine(""" p :- assertz(p), fail. p :- fail. """) assert_false("p.", e) e = get_engine(""" q :- fail. q :- assertz(q), fail. """) assert_false("q.", e)
def test_call(): e = get_engine("g(b, b).") assert_true("call(g(X, X)).", e) assert_true("X =.. [g, b, b], call(X).", e) e = get_engine(""" g(X) :- call(f(X)). g(a). g(b). f(X) :- !, h(X). f(a). f(b). h(X) :- fail. withcut(X) :- call(!), fail. withcut(a). """) heaps = collect_all(e, "g(X).") assert len(heaps) == 2 assert_true("withcut(a).", e) assert_true("call((!, true)).")
def test_arg(): assert_true("arg(1, g(a, b, c), a).") assert_true("arg(2, g(a, b, c), b).") assert_true("arg(3, g(a, b, c), c).") assert_false("arg(3, g(a, b, c), d).") assert_false("arg(0, g(a, b, c), X).") assert_false("arg(10, g(a, b, c), X).") assert_true("arg(1, g(a, b, c), X), X = a.") assert_true("arg(2, f(a, b, c), X), X = b.") assert_true("arg(3, h(a, b, c), X), X = c.") e = get_engine(""" f(1, a). f(2, b). f(3, c). """) heaps = collect_all(e, "arg(X, g(a, b, c), A), f(X, A).") assert len(heaps) == 3 assert_true("arg(X, h(a, b, c), b), X = 2.") assert_true("arg(X, h(a, b, g(X, b)), g(3, B)), X = 3, B = b.") assert_false("arg(X, a, Y).") prolog_raises("_", "arg(X, 1, Y)")
def test_not(): assert_true("not(fail).") assert_false("not(true).") e = get_engine(""" g(a, a). g(b, a). g(b, b). m(o, a). m(o, b). m(o, c). same(X, X). sibling(X, Y) :- m(Z, X), m(Z, Y), \\+same(X, Y). """) assert_true("not(g(b, c)).", e) assert_false("not(g(a, a)).", e) assert_true("\\+(g(b, c)).", e) assert_false("\\+(g(a, a)).", e) heaps = collect_all(e, "sibling(a, X).") assert len(heaps) == 2
def proveStatement(state, action, goal, prolog, predicateDict, nlpToolKit, sim, analyzedStatement, typeDict): def isPredInRule(predicate, rule): isIn = False for r in rule: if predicate in r: isIn = True break return isIn analyzedStatement, corefClusters, namedEntities = analyzedStatement stackFlag = False proof = [] force_input = False groundedStates = groundState(state, nlpToolKit, namedEntities, prolog) statePredicates = [] stateArguments = [] for groundedState in groundedStates: statePredicates.append(groundedState.split('(')[0]) stateArguments.append( groundedState[groundedState.find('(') + 1:groundedState.find(')')].split(',')) [groundedAction, actionPredicate, actionArguments] = groundAction(action, nlpToolKit, namedEntities, prolog, predicateDict, typeDict) addingQuery = groundedAction + '.' actionInKB = isFactInKB(actionPredicate, actionArguments, addingQuery, prolog, predicateDict) if not actionInKB: [prolog, sim, addingToPredicateDict] = \ addFactToKb(prolog, sim, addingQuery, actionPredicate, actionArguments, predicateDict) while not proof and not stackFlag: [groundedGoal, goalStack, bodyStack] = groundGoal(goal, predicateDict, nlpToolKit, namedEntities, prolog, typeDict, force_input) if not goalStack: break goalStack, goalPredicateStack, goalArgumentsStack = goalStack if len(goalStack) > 0: stackFlag = True for goalArgs in goalArgumentsStack: [gArg.replace('_', ' ') for gArg in goalArgs] bodyStack, bodyPredicateStack, bodyArgumentsStack = bodyStack if groundedGoal == False and goalStack == []: logging.error( 'ERROR: goal not grounded and goal stack empty. No goal to prove!!!' ) print "ERROR: goal not grounded and goal stack empty. No goal to prove!!!" return if (not groundedGoal) or force_input: goalStack, bodyStack = refineDependencyTuples( goalStack, bodyStack, typeDict, prolog) groundedGoal = goalStack[0] print "\n___________ADDING RULE__________\n" [prolog, predicateDict] = addInstructedRules(goalStack, bodyStack, prolog, predicateDict, sim) queryString = groundedGoal + '.' newQueryString, var_to_pos = prolog.parse(queryString) logging.info('queryString: {0}'.format(queryString)) print 'queryString:', queryString query = newQueryString[0] logging.info( '___________RUNNING QUERY__________,\n query: {0}'.format(query)) print "___________RUNNING QUERY__________\n\n", "query", query scores = [] depths = [] rules = [] unifications = [] queries = [] try: if prologPath == '/testnet' or prologPath == '/proofspyrolog': collect = collect_all(prolog, queryString, rules, scores, unifications, queries) if prologPath == '/spyrolog': collect = collect_all(prolog, queryString, rules, scores, unifications) logging.info('variable bindings: {0}'.format(collect)) print "\n" print "variable bindings", collect print "\n" print("__________PROOF TRACE___________\n") logging.info('__________PROOF TRACE___________') proof = collect logging.info('all proofs: {0}'.format(proof)) except Exception as e: logging.info('PROOF FAILED :( {0}'.format(e)) print "proof failed" proof = None force_input = not stackFlag acceptedProof = [] if proof: assert len(proof) == len( rules), 'the length of the proof and the trace should be the same' for p, r in zip(proof, rules): actionUsed = isPredInRule(actionPredicate, r) if actionUsed: acceptedProof.append(p[0]) print 'acceptedProof:', acceptedProof for p in acceptedProof: logging.info('acceptedProof: {0}', p) print 'p:', p if not actionInKB: prolog = removeFactFromKb(prolog, addingQuery, actionPredicate, addingToPredicateDict, predicateDict) return acceptedProof