def variablization(predicate, vars, variable_factory): if len(vars) == 0 or vars[len(vars)-1].depth < 4: for i in xrange(1, predicate.arity+1): for old_vars in choose(vars, i): new_vars = variable_factory.next_variable_sequence( predicate.arity-i, predicate.name[0].upper() + predicate.name[1:] + '_') for seq in permute(new_vars + old_vars): yield predicate(*seq), new_vars else: for old_vars in choose(vars, predicate.arity): for seq in permute(old_vars): yield predicate(*seq), []
def predicate_rules_postprocessing_compact(predicate, positive_tuples, negative_tuples): """ Removes redundant rules and terms from a predicate. This is an approximation algorithm since the optimal result is undecidable. @param predicate: The predicate whose rules are to be compacted. @type predicate: Predicate @param positive_tuples: Tuples covered by the predicate. These are used to insure that compaction does not affect the coverage of the predicate. @param negative_tuples: Tuples not covered by the predicate. These are used it insure that compaction does not affect the coverage of the predicate. """ logger.debug("Start " + predicate_rules_postprocessing_compact.func_name) rules = predicate.rules predicate.rules = [] for rule in rules: new_rule = rule predicate.rules.append(rule) covered_positive_tuples, covered_negative_tuples = ( map(lambda x: determine_tuples_covered(predicate, x), [positive_tuples, negative_tuples])) predicate.rules.pop() for i in xrange(1, len(rule.body)): found_rule = False for sub_rule_body in choose(rule.body, len(rule.body) - i): sub_rule = Rule(predicate, rule.terms, sub_rule_body) if not will_rule_halt(predicate, sub_rule): continue predicate.rules.append(sub_rule) better_rule = determine_tuples_covered_same_or_better(predicate, positive_tuples, negative_tuples, covered_positive_tuples, covered_negative_tuples) predicate.rules.pop() if better_rule: new_rule = sub_rule found_rule = True break if not found_rule: break predicate.rules.append(new_rule) rule_removed = True while rule_removed: rule_removed = False for i in xrange(len(predicate.rules)): rule = predicate.rules[i] del predicate.rules[i] if determine_tuples_covered_same_or_better(predicate, positive_tuples, negative_tuples): rule_removed = True break else: predicate.rules.insert(i, rule) logger.debug("End " + predicate_rules_postprocessing_compact.func_name)
def determine_param_orderings(predicate): logger.debug("Determining ordering for: " + str(predicate)) def establish_relationship(value_pair, index_pair, op, cmp_map): x,y = value_pair i,k = index_pair if not(cmp_map.has_key((i,k)) and cmp_map[(i,k)] == None): if op(x,y): if cmp_map.has_key((i,k)): if op != cmp_map[(i,k)]: cmp_map[(i,k)] = None else: cmp_map[(i,k)] = op elif cmp_map.has_key((i,k)) and op == cmp_map[(i,k)]: cmp_map[(i,k)] = None logger.debug(str(cmp_map)) # end establish_relationship v = UniqueVariableFactory() type_map = {} types = predicate.param_types for i, type in zip(range(0, len(types)), types): if not type_map.has_key(type): type_map[type] = [] type_map[type].append(i) pairs = [] for type in type_map.keys(): for x in choose(type_map[type], 2): pairs.append(list(x)) cmp_map = {} variables = v.next_variable_sequence(predicate.arity) logger.debug("Calling: fol_bc_ask( %s )" % predicate(*variables)) for answer in fol_bc_ask([predicate(*variables)], {}): logger.debug("Answer: " + str(answer)) for pair in pairs: i,k = pair x,y = answer[variables[i]], answer[variables[k]] logger.debug("Comparing %s and %s." % (x, y)) try: for op in [operator.lt, operator.gt, operator.eq]: establish_relationship((x,y), (i,k), op, cmp_map) except: pass return cmp_map