Ejemplo n.º 1
0
def ask():
    kb = Knowledge()
    prover = Prover(kb)

    l1 = lit(pred('y', 1), [var('X')])
    l2 = lit(pred('x', 2), [var('X'), var('Y')])
    l3 = lit(pred('z', 1), [var('Y')])

    c1 = clause(l1, [l2, l3])
    kb.assert_clause(c1)

    for z in ('alice', 'mary', 'susan'):
        head = lit(pred('z',1), [const(z)])
        body = []
        ca = clause(head, body)
        kb.assert_clause(ca)

    for x,y in [('alice', 'mary'), ('susan', 'mary')]:
        head = lit(pred('x',2), [const(x), const(y)])
        body = []
        ca = clause(head, body)
        kb.assert_clause(ca)

    query = lit(pred('y',1),[var('X')])
    answer = prover.ask(query)
    
    assert set(answer) == set([lit(pred('y',1), [const('alice')]), lit(pred('y',1), [const('susan')])])

    query = lit(pred('x',2), [var('X'), const('alice')])
    answer = prover.ask(query)
    assert not set(answer)

    query = lit(pred('nothere',1), [var('X')])
    answer = prover.ask(query)
    assert not set(answer)
Ejemplo n.º 2
0
def equals():
    kb = Knowledge()
    prover = Prover(kb)

    l1 = lit(pred('y',1), [var('X')])
    l2 = lit(pred('=',2), [var('X'), var('Y')])
    l3 = lit(pred('z',1), [var('Y')])

    c1 = clause(l1, [l2, l3])
    kb.assert_clause(c1)

    for v in ('foo', 'bar'):
        kb.assert_clause(clause(lit(pred('z',1), [const(v)]), []))

    query = lit(pred('y',1),[var('X')])
    answer = prover.ask(query)
    assert set(answer) == set([lit(pred('y',1), [const('foo')]), lit(pred('y',1), [const('bar')])])
Ejemplo n.º 3
0
def slg_factor():
    kb = Knowledge()
    prover = Prover(kb)

    x = pred('x', 1)
    y = pred('y', 2)
    z = pred('z', 1)

    # x(X) :- y(X,alice), z(alice).
    c1 = clause(lit(x, [var('X')]), [lit(y, [var('X'), const('alice')]), lit(z, [const('alice')]) ])
    # z(alice) :- | z(mary).
    c2 = clause(lit(z, [const('alice')]), [], [lit(z, [const('alice')])])

    # x(X) :- y(X, alice) | z(alice).
    ex = clause(lit(x, [var('X')]), [lit(y, [var('X'), const('alice')])], [lit(z, [const('alice')])])

    ans = prover.slg_factor(c1, lit(z, [const('alice')]), c2)
    assert ex.id == ans.id, "{} == {}".format(ex, ans)

    # tries to factor a non-delayed clause
    ans = prover.slg_factor(c1, lit(z, [const('alice')]), clause(lit(z, [const('alice')]), []))
    assert ans is None
Ejemplo n.º 4
0
def slg_resolve():
    kb = Knowledge()
    prover = Prover(kb)

    l1 = lit(pred('x',1), [var('X')])
    l2 = lit(pred('y',2), [var('X'), var('Y')])
    l3 = lit(pred('z',1), [var('Y')])
    l4 = lit(pred('z',1), [const('alice')])

    # x(X) :- y(X,Y), z(Y).
    c1 = clause(l1, [l2, l3])
    # z(alice).
    c2 = clause(l4)

    # x(X) :- y(X, alice).
    ex = clause(l1, [lit(pred('y',2), [var('X'), const('alice')])])

    ans = prover.slg_resolve(c1, l3, c2)
    assert ex.id == ans.id, "{} == {}".format(ex, ans)

    # non-unifiable
    ans = prover.slg_resolve(c1, l3, clause(lit(pred('foo',2), [var('A'), var('B')]), [lit(pred('a',1), [var('A')]), lit(pred('b',1), [var('B')])]))
    assert ans is None
Ejemplo n.º 5
0
def primitives():
    kb = Knowledge()
    prover = Prover(kb)

    def testpred(literal, prover):
        if literal[0].is_const():
            yield clause(literal)
        else:
            yield clause(lit(literal.pred, [const('foo')]))
            yield clause(lit(literal.pred, [const('bar')]))
            yield clause(lit(literal.pred, [const('baz')]))

    kb.add_primitive(pred('testpred',1), testpred)

    l1 = lit(pred('y', 1), [var('X')])
    l2 = lit(pred('testpred', 1), [var('X')])

    c1 = clause(l1, [l2])
    kb.assert_clause(c1)

    query = lit(pred('y',1),[var('X')])
    answer = prover.ask(query)
    assert set(answer) == set([lit(pred('y',1), [const('foo')]), lit(pred('y',1), [const('bar')]), lit(pred('y',1), [const('baz')])])

    query = lit(pred('y',2), [const('twelve'), var('X')])
    answer = prover.ask(query)
    assert not set(answer)

    kb.assert_clause(clause(lit(pred('testpred', 1), [const('quux')]), []))
    query = lit(pred('y',1),[var('X')])
    answer = prover.ask(query)
    assert set(answer) == set([lit(pred('y',1), [const('foo')]), lit(pred('y',1), [const('bar')]), lit(pred('y',1), [const('baz')]), lit(pred('y',1), [const('quux')])])

    query = lit(pred('y',2), [const('twelve'), var('X')])
    answer = prover.ask(query)
    assert not set(answer)