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
