def translate(task):
# Note: The function requires that the task has been normalized.
with timers.timing("Generating Datalog program"):
prog = PrologProgram()
translate_facts(prog, task)
for conditions, effect in normalize.build_exploration_rules(task):
# rule = Rule(conditions, effect)
# print("\nadding rule %s"% rule)
# prog.add_rule(rule)
prog.add_rule(Rule(conditions, effect))
# print("############################## dumping translated logic program ##############")
# prog.dump()
# print("############################## done dumping translated logic program ##############")
with timers.timing("Normalizing Datalog program", block=True):
# Using block=True because normalization can output some messages
# in rare cases.
prog.normalize()
prog.split_rules()
# print("############################## dumping normalized logic program ##############")
# prog.dump()
# print("############################## done dumping normalized logic program ##############")
return prog
def translate(task):
# Note: The function requires that the task has been normalized.
from invariant_finder import get_fluents
with timers.timing("Generating Datalog program"):
prog = PrologProgram()
translate_facts(prog, task)
fluents = get_fluents(
task) # TODO: identify implied conditions and filter automatically
for conditions, effect in normalize.build_exploration_rules(task):
if REDUCE_CONDITIONS:
# TODO: could possibly remove rules with effects that don't achieve conditions
#conditions = [condition for condition in conditions if condition.predicate not in fluents]
conditions = sorted(conditions,
key=lambda c:
(len(c.args), c.predicate not in fluents),
reverse=True)
covered_args = set()
reduced_conditions = []
for condition in conditions:
# isinstance(condition.predicate, pddl.Action) or isinstance(condition.predicate, pddl.Axiom)
if not reduced_conditions or not (set(condition.args) <=
covered_args):
covered_args.update(condition.args)
reduced_conditions.append(condition)
conditions = reduced_conditions
prog.add_rule(Rule(conditions, effect))
with timers.timing("Normalizing Datalog program", block=True):
# Using block=True because normalization can output some messages
# in rare cases.
prog.normalize()
prog.split_rules()
return prog
def translate(task):
normalize.normalize(task)
prog = PrologProgram()
translate_facts(prog, task)
for conditions, effect in normalize.build_exploration_rules(task):
prog.add_rule(Rule(conditions, effect))
prog.normalize()
prog.split_rules()
return prog
def translate(task):
normalize.normalize(task)
prog = PrologProgram()
translate_facts(prog, task)
for conditions, effect in normalize.build_exploration_rules(task):
prog.add_rule(Rule(conditions, effect))
prog.normalize()
prog.split_rules()
return prog
def translate(task):
# Note: The function requires that the task has been normalized.
prog = PrologProgram()
translate_facts(prog, task)
for conditions, effect in normalize.build_exploration_rules(task):
prog.add_rule(Rule(conditions, effect))
# Using block=True because normalization can output some messages
# in rare cases.
prog.normalize()
prog.split_rules()
return prog
def translate(task):
# Note: The function requires that the task has been normalized.
with timers.timing("Generating Datalog program"):
prog = PrologProgram()
translate_facts(prog, task)
for conditions, effect in normalize.build_exploration_rules(task):
prog.add_rule(Rule(conditions, effect))
with timers.timing("Normalizing Datalog program", block=True):
# Using block=True because normalization can output some messages
# in rare cases.
prog.normalize()
prog.split_rules()
return prog
def translate(task, add_fluents = set()):
# Note: The function requires that the task has been normalized.
with timers.timing("Generating Datalog program"):
prog = PrologProgram()
translate_facts(prog, task, add_fluents)
for conditions, effect in normalize.build_exploration_rules(task):
prog.add_rule(Rule(conditions, effect))
with timers.timing("Normalizing Datalog program", block=True):
# Using block=True because normalization can output some messages
# in rare cases.
prog.normalize()
prog.split_rules()
return prog
def translate(task):
with timers.timing("Normalizing task"):
normalize.normalize(task)
with timers.timing("Generating Datalog program"):
prog = PrologProgram()
translate_facts(prog, task)
for conditions, effect in normalize.build_exploration_rules(task):
prog.add_rule(Rule(conditions, effect))
with timers.timing("Normalizing Datalog program", block=True):
# Using block=True because normalization can output some messages
# in rare cases.
prog.normalize()
prog.split_rules()
return prog
def translate(task, keep_action_predicates=False, add_inequalities_flag=False):
# Note: The function requires that the task has been normalized.
prog = PrologProgram()
translate_facts(prog, task)
if add_inequalities_flag:
add_inequalities(prog, task)
for conditions, effect, action in normalize.build_exploration_rules(
task, add_inequalities_flag):
weight = get_action_cost(action)
if effect.predicate == "@goal-reachable":
weight = 0
prog.add_rule(Rule(conditions, effect, weight))
# Using block=True because normalization can output some messages
# in rare cases.
prog.remove_fluent_atoms_from_edb(task)
if not keep_action_predicates:
prog.remove_action_predicates()
prog.normalize()
prog.split_rules()
return prog
