def setUp(self): self.v, self.a = VariableFactory(), FamilyMemberFactory() self.kb = KnowledgeBase() v, a = self.v, self.a self.father = RuleBasedPredicate('father', (FamilyMember, FamilyMember)) self.mother = RuleBasedPredicate('mother', (FamilyMember, FamilyMember)) self.kb.add_all([self.mother, self.father])
def __define_algorithmetic_predicates(): from trimlogic.term import VariableFactory from trimlogic.predicate import CutPredicate, FailPredicate, RuleBasedPredicate global fail, cut, neg, eql v = VariableFactory() cut = CutPredicate() fail = FailPredicate() neg = RuleBasedPredicate('neg') neg.add_rule( Head=( v.Goal, ), Body=( v.Goal, cut, fail ) ) neg.add_rule( Head=( v.Goal, ) ) eql = RuleBasedPredicate('eql') eql.add_rule( Head=( v.X, v.X ) )
def testAncestor(self): v, a = self.v, self.a self.loadFamilyTree1() ancestor = RuleBasedPredicate('ancestor', (FamilyMember, FamilyMember)) self.kb.add(ancestor) positive_tuples = [[a.jane, a.ann], [a.tim, a.tom], [a.tipsy, a.billy], [a.jannet, a.billy], [a.joan, a.jane], [a.rebecca, a.ann], [a.frank, a.jane], [a.jan, a.ann], [a.jill, a.ann]] negative_tuples = [[a.tim, a.ann], [a.ann, a.billy], [a.jane, a.frank], [a.tom, a.debrah], [a.tim, a.tammy], [a.tom, a.george], [a.jane, a.joan]] foil(ancestor, positive_tuples, negative_tuples, self.kb, ordering=None) self.assertFollows(ancestor(a.bob, a.jane)) self.assertNotFollows(ancestor(a.bob, a.ian)) self.kb.remove(ancestor) self.print_rules(ancestor)
def testFindRecursiveRules(self): from trimlogic.predicate import Rule, MutableRule from trimlogic.foil import will_halt v, a = self.v, self.a self.loadFamilyTree1() mother = self.mother predicate = RuleBasedPredicate('ancestor', (FamilyMember, FamilyMember)) predicate.rules.append( Rule( predicate, (v.X, v.Y), (mother(v.X, v.Y),) ) ) current_rule = MutableRule( predicate, (v.X, v.Y), (mother(v.Z, v.Y),) ) predicate.rules.append(current_rule) recursive_literal = predicate(v.X, v.Z) ordering = find_partial_ordering_of_terms(current_rule) self.assertTrue(will_halt(predicate, recursive_literal, [v.X, v.Y], ordering))
def testGrandparent(self): import sys v, a = self.v, self.a self.loadFamilyTree1() grandfather = RuleBasedPredicate('grandfather', (FamilyMember, FamilyMember)) grandfather.arity = 2 self.kb.add(grandfather) positive_tuples = [[a.frank, a.sean], [a.tom, a.billy], [a.george, a.jan], [a.bob, a.jane], [a.sean, a.ann], [a.frank, a.sean]] negative_tuples = [[a.jannet, a.tim], [a.jane, a.alan], [a.rebecca, a.sean], [a.jan, a.ann]] foil(grandfather, positive_tuples, negative_tuples, self.kb, ordering=None) self.assertFollows(grandfather(a.george, a.tom)) self.assertFollows(grandfather(a.alan, a.jane)) self.assertNotFollows(grandfather(a.tipsy, a.billy)) self.assertNotFollows(grandfather(a.bob, a.ian)) self.kb.remove(grandfather) self.print_rules(grandfather)
def testMemberPredicate(self): print "" v, a = VariableFactory(), AtomFactory() kb = KnowledgeBase() kb.add(components) member = RuleBasedPredicate("member", (Term, dot)) kb.add(member) positive_tuples = ((1, plist([1, 2, 3, 4])), (4, plist([1, 2, 3, 4])), (5, plist([5, 4, 3, 2])), (2, plist([1, 2, 3, 4])), (3, plist([1, 2, 3, 4]))) negative_tuples = ((1, plist([2, 3, 4, 5])), (2, plist([1, 3, 4, 5])), (3, plist([1, 2, 4, 5])), (4, plist([1, 2, 3, 5])), (5, plist([1, 2, 3, 4])), (plist([1, 2]), plist([1, 2, 3, 4]))) foil(member, positive_tuples, negative_tuples, kb, ordering=None) self.assertFollows(member(11, plist([2, 3, 5, 7, 11, 13]))) self.assertNotFollows(member(12, plist([2, 3, 5, 7, 11, 13]))) self.print_rules(member)
def __define_list_predicates(): import operator from trimlogic.term import VariableFactory, Term from trimlogic.predicate import RuleBasedPredicate, ListPredicate global dot, car, cdr, cons, append, reverse, components v = VariableFactory() dot = ListPredicate('.') car = RuleBasedPredicate('car') car.add_rule( Head=( dot(v.H, v.T), v.H ) ) cdr = RuleBasedPredicate('cdr') cdr.add_rule( Head=( dot(v.H, v.T), v.T ) ) cons = RuleBasedPredicate('cons') cons.add_rule( Head=( v.H, dot(v.H1, v.T), dot(v.H, dot(v.H1, v.T)) ) ) cons.add_rule( Head=( v.H, [], dot(v.H, []) ) ) components = RuleBasedPredicate('components', (dot, Term, Term)) components.add_rule( Head=( v.X, v.H, v.T ), Body=( car(v.X, v.H), cdr(v.X, v.T ) ) ) components.param_orderings = {(0, 2):operator.gt} append = RuleBasedPredicate('append') append.add_rule( Head=( [], v.L, v.L ) ) append.add_rule( Head=( dot(v.X, v.A), v.B, dot(v.X, v.C) ), Body=( append(v.A, v.B, v.C), ) ) reverse = RuleBasedPredicate('reverse') reverse.add_rule( Head=( [], [] ) ) reverse.add_rule( Head=( dot(v.H, v.T), v.Rev ), Body=( reverse(v.T, v.Trev), append(v.Trev, plist([v.H]), v.Rev) ) )
def __init__(self): RuleBasedPredicate.__init__(self, 'is_number')