Exemple #1
0
def test_reify_object():
    obj = reify_object(Foo(1, var(3)), {var(3): 4})
    assert obj.a == 1
    assert obj.b == 4

    f = Foo(1, 2)
    assert reify_object(f, {}) is f
Exemple #2
0
def test_unify_slice():
    x = var('x')
    y = var('y')

    assert unify(slice(1), slice(1), {}) == {}
    assert unify(slice(1, 2, 3), x, {}) == {x: slice(1, 2, 3)}
    assert unify(slice(1, 2, None), slice(x, y), {}) == {x: 1, y: 2}
Exemple #3
0
def test_reify_object():
    obj = reify_object(Foo(1, var(3)), {var(3): 4})
    assert obj.a == 1
    assert obj.b == 4

    f = Foo(1, 2)
    assert reify_object(f, {}) is f
Exemple #4
0
def test_unify_slice():
    x = var('x')
    y = var('y')

    assert unify(slice(1), slice(1), {}) == {}
    assert unify(slice(1, 2, 3), x, {}) == {x: slice(1, 2, 3)}
    assert unify(slice(1, 2, None), slice(x, y), {}) == {x: 1, y: 2}
Exemple #5
0
def test_reify_object_attrs():
    x, y = var('x'), var('y')
    f, g = Foo(1, 2), Foo(x, y)
    s = {x: 1, y: 2}
    assert reify_object_attrs(g, s, ['a', 'b']) == f
    assert reify_object_attrs(g, s, ['a']) == Foo(1, y)
    assert reify_object_attrs(g, s, ['b']) == Foo(x, 2)
    assert reify_object_attrs(g, s, []) is g
Exemple #6
0
def test_reify():
    x, y, z = var(), var(), var()
    s = {x: 1, y: 2, z: (x, y)}
    assert reify(x, s) == 1
    assert reify(10, s) == 10
    assert reify((1, y), s) == (1, 2)
    assert reify((1, (x, (y, 2))), s) == (1, (1, (2, 2)))
    assert reify(z, s) == (1, 2)
Exemple #7
0
def test_reify_object_attrs():
    x, y = var('x'), var('y')
    f, g = Foo(1, 2), Foo(x, y)
    s = {x: 1, y: 2}
    assert reify_object_attrs(g, s, ['a', 'b']) == f
    assert reify_object_attrs(g, s, ['a']) ==  Foo(1, y)
    assert reify_object_attrs(g, s, ['b']) ==  Foo(x, 2)
    assert reify_object_attrs(g, s, []) is g
Exemple #8
0
def test_reify():
    x, y, z = var(), var(), var()
    s = {x: 1, y: 2, z: (x, y)}
    assert reify(x, s) == 1
    assert reify(10, s) == 10
    assert reify((1, y), s) == (1, 2)
    assert reify((1, (x, (y, 2))), s) == (1, (1, (2, 2)))
    assert reify(z, s) == (1, 2)
Exemple #9
0
def computations_for(expr):
    """ Computations that can break down expr """
    c = var('comp')
    e = var('expr')
    pred = var('predicate')
    result = run(None, c, (computes, e, c, pred),
                          (eqac, e, expr),
                          (asko, pred, True))
    return result
Exemple #10
0
def test_seq_registry():
    seq_registry.append((Foo, lambda x: (type(x), x.a, x.b)))

    x = var('x')
    y = var('y')
    f, g = Foo(1, 2), Foo(x, y)

    assert unify(f, g, {}) == {x: 1, y: 2}

    seq_registry.pop()
Exemple #11
0
def test_list_1():
    _unify.add((Foo, Foo, dict), unify_object)
    _reify.add((Foo, dict), reify_object)

    x = var('x')
    y = var('y')
    rval = run(0, (x, y), (eq, Foo(1, [2]), Foo(x, [y])))
    assert rval == ((1, 2), )

    rval = run(0, (x, y), (eq, Foo(1, [2]), Foo(x, y)))
    assert rval == ((1, [2]), )
Exemple #12
0
def test_list_1():
    _unify.add((Foo, Foo, dict), unify_object)
    _reify.add((Foo, dict), reify_object)

    x = var('x')
    y = var('y')
    rval = run(0, (x, y), (eq, Foo(1, [2]), Foo(x, [y])))
    assert rval == ((1, 2),)

    rval = run(0, (x, y), (eq, Foo(1, [2]), Foo(x, y)))
    assert rval == ((1, [2]),)
Exemple #13
0
def test_unify_isinstance_list():
    class Foo2(Foo): pass
    x = var('x')
    y = var('y')
    f, g = Foo2(1, 2), Foo2(x, y)

    _unify.add((Foo, Foo, dict), unify_object)
    _reify.add((Foo, dict), reify_object)

    assert unify(f, g, {})
    assert reify(g, {x: 1, y: 2}) == f
Exemple #14
0
def test_unify_isinstance_list():
    class Foo2(Foo):
        pass

    x = var('x')
    y = var('y')
    f, g = Foo2(1, 2), Foo2(x, y)

    _unify.add((Foo, Foo, dict), unify_object)
    _reify.add((Foo, dict), reify_object)

    assert unify(f, g, {})
    assert reify(g, {x: 1, y: 2}) == f
Exemple #15
0
def test_unify_isinstance_list():
    class Foo2(Foo): pass
    x = var('x')
    y = var('y')
    f, g = Foo2(1, 2), Foo2(x, y)

    unify_isinstance_list.append(((Foo, Foo), unify_object))
    reify_isinstance_list.append((Foo, reify_object))

    assert unify(f, g, {})
    assert reify(g, {x: 1, y: 2}) == f

    unify_isinstance_list.pop()
    reify_isinstance_list.pop()
Exemple #16
0
def test_list_1():
    from logpy.unification import unify_dispatch, reify_dispatch
    unify_dispatch[(Foo, Foo)] = unify_object
    reify_dispatch[Foo] = reify_object

    x = var('x')
    y = var('y')
    rval = run(0, (x, y), (eq, Foo(1, [2]), Foo(x, [y])))
    assert rval == ((1, 2),)

    rval = run(0, (x, y), (eq, Foo(1, [2]), Foo(x, y)))
    assert rval == ((1, [2]),)

    del reify_dispatch[Foo]
    del unify_dispatch[(Foo, Foo)]
Exemple #17
0
def logpy_join(node):
    if isinstance(node.op, tensor.Join):
        axis = node.inputs[0]
        tsrs = node.inputs[1:]
        if len(tsrs) < 2:
            return

        for i, (t0, t1) in enumerate(zip(tsrs[:-1], tsrs[1:])):
            reb_op = tensor.Rebroadcast((0, 0))
            x0 = reb_op(t0.type())
            x1 = reb_op(t1.type())
            op0 = var('op0')
            with variables(x0, x1):
                op(x[i], x[i+1])
                match = run(
                    1, [x0, x1, op0],
                    (eq, [t0, t1], [reb_op(x0), reb_op(x1)]),
                    (getattrreco, (x0, 'owner', 'op'), op0),
                    (getattrreco, (x1, 'owner', 'op'), op0),
                    (isinstanceo, op0, tensor.Elemwise),

                   )
                if match:
                    print 'MATCH', match
                else:
                    return
def test_logpy():
    x = tensor.vector()
    y = tensor.vector()
    z = tensor.inc_subtensor(x[1:3], y)
    node = z.owner

    # otw theano chokes on var attributes when nose tries to print a traceback
    # XXX this should be un-monkey-patched after the test runs by e.g. a
    # context manager decorator
    theano.gof.Apply.__repr__ = object.__repr__
    theano.gof.Apply.__str__ = object.__str__

    w = dict((name, var(name)) for name in [
        'start', 'stop', 'step', 'set_instead_of_inc', 'inputs', 'outputs',
        'inplace', 'whole_op', 'dta',
        ])

    pattern = raw_init(theano.Apply,
        op=raw_init(theano.tensor.IncSubtensor,
            idx_list=[slice(w['start'], w['stop'], w['step'])],
            inplace=w['inplace'],
            set_instead_of_inc=w['set_instead_of_inc'],
            destroyhandler_tolerate_aliased=w['dta']),
        inputs=w['inputs'],
        outputs=w['outputs'])

    match, = run(0, w, (eq, node, pattern))

    assert match['stop'] == 3
    assert match['inputs'] == [x, y]
Exemple #19
0
def test_unifiable_with_term():
    add = Op('add')
    t = MyTerm(add, (1, 2))
    assert arguments(t) == (1, 2)
    assert operator(t) == add
    assert term(operator(t), arguments(t)) == t

    x = var('x')
    assert unify(MyTerm(add, (1, x)), MyTerm(add, (1, 2)), {}) == {x: 2}
Exemple #20
0
def test_logify_slots():
    x = var('x')
    f = Aslot()
    f.a = 1
    f.b = 2
    g = Aslot()
    g.a = 1
    g.b = x
    assert unify(f, g, {}) == {x: 2}
    assert reify(g, {x: 2}) == f
Exemple #21
0
def test_unify_complex():
    assert unify((1, {2: 3}), (1, {2: 3}), {}) == {}
    assert unify((1, {2: 3}), (1, {2: 4}), {}) == False
    assert unify((1, {2: var(5)}), (1, {2: 4}), {}) == {var(5): 4}

    assert unify({1: (2, 3)}, {1: (2, var(5))}, {}) == {var(5): 3}
    assert unify({1: [2, 3]}, {1: [2, var(5)]}, {}) == {var(5): 3}
Exemple #22
0
def test_unify_complex():
    assert unify((1, {2: 3}), (1, {2: 3}), {}) == {}
    assert unify((1, {2: 3}), (1, {2: 4}), {}) == False
    assert unify((1, {2: var(5)}), (1, {2: 4}), {}) == {var(5): 4}

    assert unify({1: (2, 3)}, {1: (2, var(5))}, {}) == {var(5): 3}
    assert unify({1: [2, 3]}, {1: [2, var(5)]}, {}) == {var(5): 3}
Exemple #23
0
def test3():
    parent = Relation()
    male = Relation()

    def son(father, boy):
        return conde((parent(father, boy), male(boy)))

    fact(parent, "Abraham", "Isaac")
    fact(male, "Abraham")
    fact(male, "Isaac")

    x = var()
    assert ("Isaac",) == run(0, x, son("Abraham", x))
Exemple #24
0
def test_objects_full():
    _unify.add((Foo, Foo, dict), unify_object)
    _unify.add((Bar, Bar, dict), unify_object)
    _reify.add((Foo, dict), reify_object)
    _reify.add((Bar, dict), reify_object)

    assert unify_object(Foo(1, Bar(2)), Foo(1, Bar(var(3))), {}) == {var(3): 2}
    assert reify(Foo(var('a'), Bar(Foo(var('b'), 3))),
                 {var('a'): 1, var('b'): 2}) == Foo(1, Bar(Foo(2, 3)))
Exemple #25
0
def test_objects_full():
    _unify.add((Foo, Foo, dict), unify_object)
    _unify.add((Bar, Bar, dict), unify_object)
    _reify.add((Foo, dict), reify_object)
    _reify.add((Bar, dict), reify_object)

    assert unify_object(Foo(1, Bar(2)), Foo(1, Bar(var(3))), {}) == {var(3): 2}
    assert reify(Foo(var('a'), Bar(Foo(var('b'), 3))), {
        var('a'): 1,
        var('b'): 2
    }) == Foo(1, Bar(Foo(2, 3)))
Exemple #26
0
def test_objects_full():
    unify_dispatch[(Foo, Foo)] = unify_object
    unify_dispatch[(Bar, Bar)] = unify_object
    reify_dispatch[Foo] = reify_object
    reify_dispatch[Bar] = reify_object

    assert unify_object(Foo(1, Bar(2)), Foo(1, Bar(var(3))), {}) == {var(3): 2}
    assert reify(Foo(var('a'), Bar(Foo(var('b'), 3))),
                 {var('a'): 1, var('b'): 2}) == Foo(1, Bar(Foo(2, 3)))


    del reify_dispatch[Bar]
    del reify_dispatch[Foo]
    del unify_dispatch[(Foo, Foo)]
    del unify_dispatch[(Bar, Bar)]
Exemple #27
0
from logpy import run, var, conde, Relation, facts
parent = Relation()
facts(parent, ('Homer', 'Lisa'), ('Homer', 'Bart'), ('Abe', 'Homer'))

x = var()
y = var()
print(run(1, x, parent(x, 'Bart')))
print(run(2, x, parent(
    'Homer',
    x,
)))
y = var()
print(run(1, x, parent(x, y), parent(y, 'Bart')))


def grandparent(x, z):
    y = var()
    return conde((parent(x, y), parent(y, z)))


print(run(1, x, grandparent(x, 'Bart')))
Exemple #28
0
def grandparent(x, z):
    y = var()
    return conde((parent(x,y), parent(y,z)))
Exemple #29
0
def aunty(x, y):
    z = var()
    return conde((uncle(z, y), Couple(z, x), Female(x)))
Exemple #30
0
def sister(x, y):
    z = var()
    return conde((parents(z, x), parents(z, y), Female(x)))
Exemple #31
0
from logpy import run, var, conde, Relation, facts
parent = Relation()
facts(parent, ('Homer', 'Lisa'),
      ('Homer', 'Bart'),
      ('Abe', 'Homer'))

x = var()
y = var()
print(run(1, x, parent(x, 'Bart')))
print(run(2, x, parent('Homer', x,)))
y = var()
print(run(1, x, parent(x, y),parent(y, 'Bart')))


def grandparent(x, z):
    y = var()
    return conde((parent(x,y), parent(y,z)))

print(run (1,x,grandparent(x, 'Bart')))


Exemple #32
0
def grandparent(x, y):
    temp = var()
    return conde((parent(x, temp), parent(temp, y)))
Exemple #33
0
def uncle(x, y):
    temp = var()
    return conde((father(temp, x), grandparent(temp, y)))
Exemple #34
0
def grandparents(x, y):
    z = var()
    return conde((parents(x, z), parents(z, y)))
Exemple #35
0
from logpy import run, var, fact
from logpy.assoccomm import eq_assoccomm as eq
from logpy.assoccomm import commutative, associative

# Define some dummy Operationss
add = 'add'
mul = 'mul'
# Declare that these ops are commutative using the facts system
fact(commutative, mul)
fact(commutative, add)
fact(associative, mul)
fact(associative, add)

# Define some wild variables
x, y = var('x'), var('y')

# Two expressions to match
pattern = (mul, (add, 1, x), y)                # (1 + x) * y
expr    = (mul, 2, (add, 3, 1))                # 2 * (3 + 1)
print run(0, (x,y), eq(pattern, expr))         # prints ((3, 2),) meaning
                                               #   x matches to 3
                                               #   y matches to 2
Exemple #36
0
def grandfather(x, y):
    z = var()
    return conde((grandparents(x, y), Male(x)))
Exemple #37
0
def test_unify_seq():
    assert unify((1, 2), (1, 2), {}) == {}
    assert unify([1, 2], [1, 2], {}) == {}
    assert unify((1, 2), (1, 2, 3), {}) == False
    assert unify((1, var(1)), (1, 2), {}) == {var(1): 2}
    assert unify((1, var(1)), (1, 2), {var(1): 3}) == False
Exemple #38
0
def test_reify_list():
    x, y = var(), var()
    s = {x: 2, y: 4}
    e = [1, [x, 3], y]
    assert reify(e, s) == [1, [2, 3], 4]
Exemple #39
0
def grandparent(x, z):
    y = var()
    return conde((parent(x, y), parent(y, z)))
Exemple #40
0
def grandmother(x, y):
    z = var()
    return conde((grandparents(x, y), Female(x)))
def cal_relation():
    txt.delete(0.0, 'end')
    name = e1.get()
    name2 = e2.get()
    if __name__ == '__main__':
        Root = Relation()
    with open('project.json') as f:
        d = json.loads(f.read())

    for item in d['Root']:
        facts(Root, (list(item.keys())[0], list(item.values())[0]))

    x = var()

    # Depository
    if (name == 'Depository' or name2 == 'Depository'):
        if (name == 'Depository'):
            output = run(0, x, Root(name, x))
        else:
            output = run(0, x, Root(name2, x))

        ##print("\nList of " + name + "'s children:")
        for item in output:
            if ((name2 == "Stock Exchange" and name == "Depository")
                    or (name == "Stock Exchange" and name2 == "Depository")):
                txt.insert(
                    END,
                    "It is regulator of Shares where all the Share of Stock exchange are strored"
                )
                break
            if ((name2 == "Customer" and name == "Depository")
                    or (name == "Customer" and name2 == "Depository")):
                txt.insert(
                    END,
                    "Individual Shares of Each Person are Contained by depository"
                )
                break
            if ((name2 == "Broker" and name == "Depository")
                    or (name == "Broker" and name2 == "Depository")):
                txt.insert(
                    END,
                    "A stock broker connects the buyers and sellers of stocks,While a depository participant is described as an agent of the depository"
                )
                break
            if ((name2 == "Divident" and name == "Depository")
                    or (name == "Divident" and name2 == "Depository")):
                txt.insert(
                    END,
                    "Globally, distribution of dividends is by depositories")
                break
            else:
                txt.insert(
                    END,
                    "This relationship is Not Defined Directly or may be some Alphabeticall Error"
                )
                break

    #Customer
    elif (name == 'Customer' or name2 == 'Customer'):
        if (name == 'Customer'):
            output = run(0, x, Root(name, x))
        else:
            output = run(0, x, Root(name2, x))

        ##print("\nList of " + name + "'s children:")
        for item in output:
            if ((name2 == "Stock Exchange" and name == "Customer")
                    or (name == "Stock Exchange" and name2 == "Customer")):
                txt.insert(
                    END,
                    "Stock exchange is a place where the trading is executed and from here Customer get the idea to buy any share or not"
                )
                break
            if ((name2 == "Seller" and name == "Customer")
                    or (name == "Seller" and name2 == "Customer")):
                txt.insert(
                    END,
                    "Seller who sells and Customer who are ready to buy the shares"
                )
                break
            if ((name2 == "Divident" and name == "Customer")
                    or (name == "Divident" and name2 == "Customer")):
                txt.insert(
                    END,
                    "After Earning From the shares as a profit we get a divident as we get a interest in Banks"
                )
                break
            if ((name2 == "DEMAT ACC." and name == "Customer")
                    or (name == "DEMAT ACC." and name2 == "Customer")):
                txt.insert(
                    END,
                    "Where Customer Can go through the detail of the personal invested shares through Demat Account"
                )
                break
            if ((name2 == "Broker" and name == "Customer")
                    or (name == "Broker" and name2 == "Customer")):
                txt.insert(
                    END,
                    "Who acts as a intermediate between Customer and Stock market and helps him to invest in shares"
                )
                break
            if ((name2 == "Registrar" and name == "Customer")
                    or (name == "Registrar" and name2 == "Customer")):
                txt.insert(
                    END,
                    "A registrar is a bank or a similar company that is responsible for recordkeeping of bondholders and shareholders. "
                )
                break
            else:
                txt.insert(
                    END,
                    "This relationship is Not Defined Directly or may be some Alphabeticall Error"
                )
                break

    #Demat Acc.
    elif (name == "DEMAT ACC." or name2 == "DEMAT ACC."):
        if (name == "DEMAT ACC."):
            output = run(0, x, Root(name, x))
        else:
            output = run(0, x, Root(name2, x))

        ##print("\nList of " + name + "'s children:")
        for item in output:
            if ((name2 == "Seller" and name == "DEMAT ACC.")
                    or (name == "Seller" and name2 == "DEMAT ACC.")):
                txt.insert(
                    END,
                    "Seller sells their share after it collect the remaining shares informtion from DEMAT Account"
                )
                break
            if ((name2 == "Divident" and name == "DEMAT ACC.")
                    or (name == "Divident" and name2 == "DEMAT ACC.")):
                txt.insert(
                    END,
                    "Divident is Generated only u have Demat acc. becoz it contain all your information"
                )
                break
            if ((name2 == "Broker" and name == "DEMAT ACC.")
                    or (name == "Broker" and name2 == "DEMAT ACC.")):
                txt.insert(
                    END,
                    "Broker Provide you the Demat Account Where u get the information of all Shares"
                )
                break
            if ((name2 == "Stock Exchange" and name == "DEMAT ACC.")
                    or (name == "Stock Exchange" and name2 == "DEMAT ACC.")):
                txt.insert(
                    END,
                    "After invested in Shares with the help of Stock exchange we are ready to update our Demat Account"
                )
                break
            else:
                txt.insert(
                    END,
                    "This relationship is Not Defined Directly or may be some Alphabeticall Error"
                )
                break

    #Clearing House
    elif (name == "Clearing House" or name2 == "Clearing House"):
        if (name == "Clearing House"):
            output = run(0, x, Root(name, x))
        else:
            output = run(0, x, Root(name2, x))

        ##print("\nList of " + name + "'s children:")
        for item in output:
            if ((name2 == "Stock Exchange" and name == "Clearing House") or
                (name == "Stock Exchange" and name2 == "Clearing House")):
                txt.insert(
                    END,
                    "A clearing house acts as an intermediary between a buyer and seller and seeks to ensure that the process from trade inception to settlement is smooth."
                )
                break
            else:
                txt.insert(
                    END,
                    "This relationship is Not Defined Directly or may be some Alphabeticall Error"
                )
                break
    #Divident
    elif (name == "Divident" or name2 == "Divident"):
        if (name == "Divident"):
            output = run(0, x, Root(name, x))
        else:
            output = run(0, x, Root(name2, x))

        ##print("\nList of " + name + "'s children:")
        for item in output:
            if ((name2 == "Registrar" and name == "Divident")
                    or (name == "Registrar" and name2 == "Divident")):
                txt.insert(
                    END,
                    "The registrar determines which shareholders are paid a cash or stock dividend."
                )
                break
            else:
                txt.insert(
                    END,
                    "This relationship is Not Defined Directly or may be some Alphabeticall Error"
                )
                break
    else:
        txt.insert(
            END,
            "This relationship is Not Defined Directly or may be some Alphabeticall Error"
        )
Exemple #42
0
def sibling(x, y):
    z = var()
    return conde((parents(z, x), parents(z, y)))
Exemple #43
0
def test_reify_dict():
    x, y = var(), var()
    s = {x: 2, y: 4}
    e = {1: x, 3: {5: y}}
    assert reify(e, s) == {1: 2, 3: {5: 4}}
Exemple #44
0
def test_reify_slice():
    x = var('x')
    assert reify(slice(1, var(2), 3), {var(2): 10}) == slice(1, 10, 3)
Exemple #45
0
def test_reify_complex():
    x, y = var(), var()
    s = {x: 2, y: 4}
    e = {1: [x], 3: (y, 5)}

    assert reify(e, s) == {1: [2], 3: (4, 5)}
Exemple #46
0
def test_unify_object_attrs():
    x, y = var('x'), var('y')
    f, g = Foo(1, 2), Foo(x, y)
    assert unify_object_attrs(f, g, {}, ['a']) == {x: 1}
    assert unify_object_attrs(f, g, {}, ['b']) == {y: 2}
    assert unify_object_attrs(f, g, {}, []) == {}
Exemple #47
0
def test_unify():
    assert unify(1, 1, {}) == {}
    assert unify(1, 2, {}) == False
    assert unify(var(1), 2, {}) == {var(1): 2}
    assert unify(2, var(1), {}) == {var(1): 2}
Exemple #48
0
from logpy import Relation, facts, run, conde, var, eq

father = Relation()
mother = Relation()

facts(father, ('Vito', 'Michael'), ('Vito', 'Sonny'), ('Vito', 'Fredo'),
      ('Michael', 'Anthony'), ('Michael', 'Mary'), ('Sonny', 'Vicent'),
      ('Sonny', 'Francesca'), ('Sonny', 'Kathryn'), ('Sonny', 'Frank'),
      ('Sonny', 'Santino'))

facts(mother, ('Carmela', 'Michael'), ('Carmela', 'Sonny'),
      ('Carmela', 'Fredo'), ('Kay', 'Mary'), ('Kay', 'Anthony'),
      ('Sandra', 'Francesca'), ('Sandra', 'Kathryn'), ('Sandra', 'Frank'),
      ('Sandra', 'Santino'))

q = var()

print run(0, q, father('Vito', q))  # Vito is the father of who?
# ('Sonny', 'Michael', 'Fredo')

print run(0, q, father(q, 'Michael'))  # Who is the father of Michael?
# ('Vito',)


def parent(p, child):
    return conde([father(p, child)], [mother(p, child)])


print run(0, q, parent(q, 'Michael'))  # Who is a parent of Michael?
# ('Vito', 'Carmela')
Exemple #49
0
def test_unify_dict():
    assert unify({1: 2}, {1: 2}, {}) == {}
    assert unify({1: 2}, {1: 3}, {}) == False
    assert unify({2: 2}, {1: 2}, {}) == False
    assert unify({1: var(5)}, {1: 2}, {}) == {var(5): 2}
Exemple #50
0
def grandparent(gparent, child):
    p = var()
    return conde((parent(gparent, p), parent(p, child)))
Exemple #51
0
from logpy import run, var, fact
import logpy.assoccomm as la

# Define mathematical operations
add = 'addition'
mul = 'multiplication'

# Declare that these operations are commutative
# using the facts system
fact(la.commutative, mul)
fact(la.commutative, add)
fact(la.associative, mul)
fact(la.associative, add)

# Define some variables
a, b, c = var('a'), var('b'), var('c')

# Generate expressions
expression_orig = (add, (mul, 3, -2), (mul, (add, 1, (mul, 2, 3)), -1))
expression1 = (add, (mul, (add, 1, (mul, 2, a)), b), (mul, 3, c))
expression2 = (add, (mul, c, 3), (mul, b, (add, (mul, 2, a), 1)))
expression3 = (add, (add, (mul, (mul, 2, a), b), b), (mul, 3, c))

# Compare expressions
print(run(0, (a, b, c), la.eq_assoccomm(expression1, expression_orig)))
print(run(0, (a, b, c), la.eq_assoccomm(expression2, expression_orig)))
print(run(0, (a, b, c), la.eq_assoccomm(expression3, expression_orig)))
Exemple #52
0
def sibling(a, b):
    p = var()
    return conde((parent(p, a), parent(p, b)))
Exemple #53
0
    return conde((mother(x, temp), parent(temp, y)))

if __name__ == '__main__':
    father = Relation()
    mother = Relation()

    with open('relationships.json') as f:
        d = json.loads(f.read())

    for item in d['father']:
        facts(father, (list(item.keys())[0], list(item.values())[0]))

    for item in d['mother']:
        facts(mother, (list(item.keys())[0], list(item.values())[0]))

    x = var()

    # John's children
    '''name = 'John'
    output = run(0, x, father(name, x))
    print("\nList of " + name + "'s children:")
    for item in output:
        print(item)
    # William's mother
    name = 'William'
    output = run(0, x, mother(x, name))[0]
    print("\n" + name + "'s mother:\n" + output)
    # Adam's parents
    name = 'Adam'
    output = run(0, x, parent(x, name))
    print("\nList of " + name + "'s parents:")
Exemple #54
0
if __name__ == '__main__':
    father = Relation()
    mother = Relation()

    with open('LAB1/relationships.json') as f:
        d = json.loads(f.read())

    #Read the data and add them to our fact base
    for item in d['father']:
        facts(father, (list(item.keys())[0], list(item.values())[0]))

    for item in d['mother']:
        facts(mother, (list(item.keys())[0], list(item.values())[0]))

    #define the variable x
    x = var()

    #let's ask who John's children are.
    name = 'John'
    output = run(0, x, father(name, x))
    print("\n list of" + name + " 's children:")
    for item in output:
        print(item)

    #who is William's mother?
    name = 'William'
    output = run(0, x, mother(x, name))[0]
    print('\n' + name + " 's mother:\n" + output)

    #who are Adam's parents?
    name = 'Adam'
Exemple #55
0
def sibling(x, y):
    temp = var()
    return conde((parent(temp, x), parent(temp, y)))
Exemple #56
0
from logpy import var
from logpy.arith import lt, gt, lte, gte, add, sub, mul, mod

x = var('x')
y = var('y')
def results(g):
    return list(g({}))

def test_lt():
    assert results(lt(1, 2))
    assert not results(lt(2, 1))
    assert not results(lt(2, 2))

def test_gt():
    assert results(gt(2, 1))
    assert not results(gt(1, 2))
    assert not results(gt(2, 2))

def test_lte():
    assert results(lte(2, 2))

def test_gte():
    assert results(gte(2, 2))

def test_add():
    assert results(add(1, 2, 3))
    assert not results(add(1, 2, 4))
    assert results(add(1, 2, 3))

    assert results(add(1, 2, x)) == [{x: 3}]
    assert results(add(1, x, 3)) == [{x: 2}]
Exemple #57
0
def grandmother(x, y):
    temp = var()
    return conde((mother(x, temp), parent(temp, y)))
Exemple #58
0
def brother(x, y):
    z = var()
    return conde((parents(z, x), parents(z, y), Male(x)))