def main():
args = parse_args()
timer = timers.Timer()
with timers.timing("Parsing", True):
task = pddl.open(task_filename=args.task, domain_filename=args.domain)
with timers.timing("Normalizing task"):
normalize.normalize(task)
task.INVARIANT_TIME_LIMIT = int(args.inv_limit)
if args.generate_relaxed_task:
# Remove delete effects.
for action in task.actions:
for index, effect in reversed(list(enumerate(action.effects))):
if effect.literal.negated:
del action.effects[index]
sas_task = pddl_to_sas(task)
########### dump_statistics(sas_task).
with timers.timing("Writing output"):
with open(args.sas_name, "w") as output_file:
sas_task.output(output_file)
def get_groups(task, safe=True, reachable_action_params=None):
with timers.timing("Finding invariants"):
invariants = list(find_invariants(task, safe, reachable_action_params))
invariants = sorted(invariants)
with timers.timing("Checking invariant weight"):
result = list(useful_groups(invariants, task.init))
return result
def main():
timer = timers.Timer()
with timers.timing("Parsing", True):
task = pddl_parser.open(domain_filename=options.domain,
task_filename=options.task)
with timers.timing("Normalizing task"):
normalize.normalize(task)
if options.generate_relaxed_task:
# Remove delete effects.
for action in task.actions:
for index, effect in reversed(list(enumerate(action.effects))):
if effect.literal.negated:
del action.effects[index]
sas_task = pddl_to_sas(task)
dump_statistics(sas_task)
with timers.timing("Writing output"):
with open("output.sas", "w") as output_file:
sas_task.output(output_file)
print("Done! %s" % timer)
global t1, t2
t2 = time.time() - t2
print('Time1:', t1)
print('Time2:', t2)
def main():
print("--------------FOND Translator------------")
args = parse_args()
timer = timers.Timer()
with timers.timing("Parsing", True):
task = pddl.open(task_filename=args.task, domain_filename=args.domain)
# for test:
print();
print("Problem Filename = " + args.task);
print("Domain Filename = " + args.domain);
print();
with timers.timing("Normalizing task"):
normalize.normalize(task)
if args.generate_relaxed_task:
# Remove delete effects.
for action in task.actions:
for index, effect in reversed(list(enumerate(action.effects))):
if effect.literal.negated:
del action.effects[index]
sas_task = pddl_to_sas(task)
dump_statistics(sas_task)
with timers.timing("Writing output"):
with open("..\\webapps\\LunaPlanner\\translator_output\\output.sas", "w") as output_file:
sas_task.output(output_file)
print()
print("SAS file saved at: " + output_file.name)
print("Done! %s" % timer)
def main():
timer = timers.Timer()
with timers.timing("Parsing", True):
task = pddl_parser.open(domain_filename=options.domain,
task_filename=options.task)
# Alberto Pozanco
"""global actions_that_achieve
if task.goal.negate:
goal_predicate = task.goal.predicate
goal_tuple = task.goal.key
for action in task.actions:
for effect in action.effects:
if effect.literal.predicate == goal_predicate:
actions_that_achieve.append([action.name,goal_tuple])
break"""
with timers.timing("Normalizing task"):
normalize.normalize(task)
if options.generate_relaxed_task:
# Remove delete effects.
for action in task.actions:
for index, effect in reversed(list(enumerate(action.effects))):
if effect.literal.negated:
del action.effects[index]
sas_task = pddl_to_sas(task)
dump_statistics(sas_task)
with timers.timing("Writing output"):
with open(options.sas_file, "w") as output_file:
sas_task.output(output_file)
print("Done! %s" % timer)
def main():
options, args = parse_options()
check_python_version(options.force_old_python)
timer = timers.Timer()
with timers.timing("Parsing", True):
task = pddl.open()
with timers.timing("Normalizing task"):
normalize.normalize(task)
if options.generate_relaxed_task:
# Remove delete effects.
for action in task.actions:
for index, effect in reversed(list(enumerate(action.effects))):
if effect.literal.negated:
del action.effects[index]
sas_task = pddl_to_sas(task)
dump_statistics(sas_task)
with timers.timing("Writing output"):
with open("output.sas", "w") as output_file:
sas_task.output(output_file)
print("Done! %s" % timer)
def compute_model(prog):
with timers.timing("Preparing model"):
rules = convert_rules(prog)
unifier = Unifier(rules)
# unifier.dump()
fact_atoms = sorted(fact.atom for fact in prog.facts)
queue = Queue(fact_atoms)
print("Generated %d rules." % len(rules))
with timers.timing("Computing model"):
relevant_atoms = 0
auxiliary_atoms = 0
while queue:
next_atom = queue.pop()
pred = next_atom.predicate
if isinstance(pred, str) and "$" in pred:
auxiliary_atoms += 1
else:
relevant_atoms += 1
matches = unifier.unify(next_atom)
for rule, cond_index in matches:
rule.update_index(next_atom, cond_index)
rule.fire(next_atom, cond_index, queue.push)
print("%d relevant atoms" % relevant_atoms)
print("%d auxiliary atoms" % auxiliary_atoms)
print("%d final queue length" % len(queue.queue))
print("%d total queue pushes" % queue.num_pushes)
return queue.queue
def compute_groups(task, atoms, reachable_action_params):
groups = invariant_finder.get_groups(task, reachable_action_params)
with timers.timing("Instantiating groups"):
groups = instantiate_groups(groups, task, atoms)
# Sort here already to get deterministic mutex groups.
groups = sort_groups(groups)
# TODO: I think that collect_all_mutex_groups should do the same thing
# as choose_groups with partial_encoding=False, so these two should
# be unified.
with timers.timing("Collecting mutex groups"):
mutex_groups = collect_all_mutex_groups(groups, atoms)
with timers.timing("Choosing groups", block=True):
groups = choose_groups(groups, atoms)
groups = sort_groups(groups)
with timers.timing("Building translation key"):
translation_key = build_translation_key(groups)
if DEBUG:
for group in groups:
if len(group) >= 2:
print("{%s}" % ", ".join(map(str, group)))
return groups, mutex_groups, translation_key
def main():
args = parse_args()
timer = timers.Timer()
with timers.timing("Parsing", True):
task = pddl.open(task_filename=args.task,
domain_filename=args.domain,
addl_filename=args.addl)
with timers.timing("Normalizing task"):
normalize.normalize(task)
if args.generate_relaxed_task:
# Remove delete effects.
for action in task.actions:
for index, effect in reversed(list(enumerate(action.effects))):
if effect.literal.negated:
del action.effects[index]
output_file = args.output_file
use_proto = args.use_proto
print('Use Proto:', use_proto)
sas_task = pddl_to_sas(task, args.agent_id, args.agent_url)
dump_statistics(sas_task)
with timers.timing("Writing output"):
with open(output_file, "w") as output_file:
if use_proto:
sas_task.output_proto(output_file)
else:
sas_task.output(output_file)
print("Done! %s" % timer)
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 main():
timer = timers.Timer()
with timers.timing("Parsing", True):
task = pddl_parser.open(
domain_filename=options.domain, task_filename=options.task)
with timers.timing("Normalizing task"):
normalize.normalize(task)
if options.generate_relaxed_task:
# Remove delete effects.
for action in task.actions:
for index, effect in reversed(list(enumerate(action.effects))):
if effect.literal.negated:
del action.effects[index]
sas_task = pddl_to_sas(task)
dump_statistics(sas_task)
with timers.timing("Writing output"):
with open("output.sas", "w") as output_file:
sas_task.output(output_file)
print("Done! %s" % timer)
global t1, t2
t2 = time.time() - t2
print('Time1:', t1)
print('Time2:', t2)
def get_groups(task, safe=True, reachable_action_params=None):
with timers.timing("Finding invariants"):
invariants = list(find_invariants(task, safe, reachable_action_params))
invariants = sorted(invariants)
with timers.timing("Checking invariant weight"):
result = list(useful_groups(invariants, task.init))
return result
def main():
print("-------------POND Translator-----------")
args = parse_args()
timer = timers.Timer()
with timers.timing("Parsing", True):
task = pddl.open(task_filename=args.task, domain_filename=args.domain)
print();
print("Problem Filename = " + args.task);
print("Domain Filename = " + args.domain);
print();
with timers.timing("Normalizing task"):
normalize.normalize(task)
if args.generate_relaxed_task:
# Remove delete effects.
for action in task.actions:
for index, effect in reversed(list(enumerate(action.effects))):
if effect.literal.negated:
del action.effects[index]
sas_task = pddl_to_sas(task)
dump_statistics(sas_task)
if not sas_task is None:
with timers.timing("Writing output"):
with open("..\\webapps\\LunaPlanner\\translator_output\\output.sas", "w") as output_file:
sas_task.output(output_file)
print()
print("SAS file saved at: " + output_file.name)
print("Done! %s" % timer)
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 compute_groups(task, atoms, reachable_action_params):
groups = invariant_finder.get_groups(task, reachable_action_params)
with timers.timing("Instantiating groups"):
groups = instantiate_groups(groups, task, atoms)
# Sort here already to get deterministic mutex groups.
groups = sort_groups(groups)
# TODO: I think that collect_all_mutex_groups should do the same thing
# as choose_groups with partial_encoding=False, so these two should
# be unified.
with timers.timing("Collecting mutex groups"):
mutex_groups = collect_all_mutex_groups(groups, atoms)
with timers.timing("Choosing groups", block=True):
groups = choose_groups(groups, atoms)
groups = sort_groups(groups)
with timers.timing("Building translation key"):
translation_key = build_translation_key(groups)
if DEBUG:
for group in groups:
if len(group) >= 2:
print("{%s}" % ", ".join(map(str, group)))
return groups, mutex_groups, translation_key
def main():
args = parse_args()
timer = timers.Timer()
with timers.timing("Parsing", True):
task = pddl.open(task_filename=args.task, domain_filename=args.domain)
with timers.timing("Normalizing task"):
normalize.normalize(task)
if args.generate_relaxed_task:
# Remove delete effects.
for action in task.actions:
for index, effect in reversed(list(enumerate(action.effects))):
if effect.literal.negated:
del action.effects[index]
sas_task = pddl_to_sas(task)
dump_statistics(sas_task)
if not sas_task is None:
with timers.timing("Writing output"):
with open("output.sas", "w") as output_file:
sas_task.output(output_file)
print("Done! %s" % timer)
def main():
print('HOLAAAAAAAAAAAAAAAAAAAAAAA')
args = parse_args()
timer = timers.Timer()
with timers.timing("Parsing", True):
task = pddl.open(task_filename=args.task, domain_filename=args.domain)
with timers.timing("Normalizing task"):
normalize.normalize(task)
task.INVARIANT_TIME_LIMIT = int(args.inv_limit)
if args.generate_relaxed_task:
# Remove delete effects.
for action in task.actions:
for index, effect in reversed(list(enumerate(action.effects))):
if effect.literal.negated:
del action.effects[index]
sas_task = pddl_to_sas(task)
assert len(sas_task.operators) == len(set([o.name for o in sas_task.operators])), \
"Error: Operator names (with parameters) must be unique"
dump_statistics(sas_task)
with timers.timing("Writing output"):
with open(args.sas_name, "w") as output_file:
sas_task.output(output_file)
print("Done! %s" % timer)
def main():
args = parse_args()
timer = timers.Timer()
with timers.timing("Parsing", True):
task = pddl.open(task_filename=args.task,
domain_filename=args.domain,
addl_filename=args.addl)
with timers.timing("Normalizing task"):
normalize.normalize(task)
if args.generate_relaxed_task:
# Remove delete effects.
for action in task.actions:
for index, effect in reversed(list(enumerate(action.effects))):
if effect.literal.negated:
del action.effects[index]
output_file = args.output_file
use_proto = args.use_proto
print('Use Proto:', use_proto)
sas_task = pddl_to_sas(task, args.agent_id, args.agent_url)
dump_statistics(sas_task)
with timers.timing("Writing output"):
with open(output_file, "w") as output_file:
if use_proto:
sas_task.output_proto(output_file)
else:
sas_task.output(output_file)
print("Done! %s" % timer)
def partial_grounding_compute_model(prog, action_prioritizer):
with timers.timing("Preparing model"):
rules = convert_rules(prog)
unifier = Unifier(rules)
# unifier.dump()
fact_atoms = sorted(fact.atom for fact in prog.facts)
queue = ActionPriorityQueue(fact_atoms, action_prioritizer)
print("Generated %d rules." % len(rules))
with timers.timing("Computing model"):
num_pops = 0
relevant_atoms = 0
auxiliary_atoms = 0
while queue:
next_atom = queue.pop()
num_pops += 1
pred = next_atom.predicate
if isinstance(pred, str) and "$" in pred:
auxiliary_atoms += 1
else:
relevant_atoms += 1
matches = unifier.unify(next_atom)
for rule, cond_index in matches:
rule.update_index(next_atom, cond_index)
rule.fire(next_atom, cond_index, queue.push)
while queue.new_facts:
atom_to_yield = queue.new_facts.pop()
yield atom_to_yield
if isinstance(next_atom.predicate, pddl.Action):
yield next_atom
print("%d relevant atoms" % relevant_atoms)
print("%d auxiliary atoms" % auxiliary_atoms)
print("%d final queue length" % num_pops)
print("%d total queue pushes" % queue.num_pushes)
return
def compute_model(prog):
with timers.timing("Preparing model"):
rules = convert_rules(prog)
unifier = Unifier(rules)
# unifier.dump()
fact_atoms = sorted(fact.atom for fact in prog.facts)
queue = Queue(fact_atoms)
print("Generated %d rules." % len(rules))
with timers.timing("Computing model"):
relevant_atoms = 0
auxiliary_atoms = 0
while queue:
if options.total_queue_pushes > 0 and queue.num_pushes > options.total_queue_pushes:
print("%d > %d total queue pushes raise" %
(queue.num_pushes, options.total_queue_pushes))
## For a full list of exit codes, please see driver/returncodes.py.
OUT_OF_TOTAL_QUEUE_PUSHES = 150
sys.exit(OUT_OF_TOTAL_QUEUE_PUSHES)
next_atom = queue.pop()
pred = next_atom.predicate
if isinstance(pred, str) and "$" in pred:
auxiliary_atoms += 1
else:
relevant_atoms += 1
matches = unifier.unify(next_atom)
for rule, cond_index in matches:
rule.update_index(next_atom, cond_index)
rule.fire(next_atom, cond_index, queue.push)
print("%d relevant atoms" % relevant_atoms)
print("%d auxiliary atoms" % auxiliary_atoms)
print("%d final queue length" % len(queue.queue))
print("%d total queue pushes" % queue.num_pushes)
return queue.queue
def main():
timer = timers.Timer()
with timers.timing("Parsing", True):
task = pddl_parser.open(task_filename=options.task, domain_filename=options.domain)
with timers.timing("Normalizing task"):
normalize.normalize(task)
if options.generate_relaxed_task:
# Remove delete effects.
for action in task.actions:
for index, effect in reversed(list(enumerate(action.effects))):
if effect.literal.negated:
del action.effects[index]
sas_task = pddl_to_sas(task)
dump_statistics(sas_task)
# Print pddl if a transormation option is selected.
if options.exp or options.evmdd:
pddl_parser.print_pddl(options.domain, sas_task, task, [])
print("done!")
exit(0)
with timers.timing("Writing output"):
with open("output.sas", "w") as output_file:
sas_task.output(output_file)
print("Done! %s" % timer)
def compute_model(prog):
with timers.timing("Preparing model"):
rules = convert_rules(prog)
unifier = Unifier(rules)
# unifier.dump()
fact_atoms = [fact.atom for fact in prog.facts]
queue = Queue(fact_atoms)
print("Generated %d rules." % len(rules))
with timers.timing("Computing model"):
relevant_atoms = 0
auxiliary_atoms = 0
while queue:
next_atom = queue.pop()
pred = next_atom.predicate
if isinstance(pred, str) and "$" in pred:
auxiliary_atoms += 1
else:
relevant_atoms += 1
matches = unifier.unify(next_atom)
for rule, cond_index in matches:
rule.update_index(next_atom, cond_index)
rule.fire(next_atom, cond_index, queue.push)
print("%d relevant atoms" % relevant_atoms)
print("%d auxiliary atoms" % auxiliary_atoms)
print("%d final queue length" % len(queue.queue))
print("%d total queue pushes" % queue.num_pushes)
return queue.queue
def main():
options, args = parse_options()
check_python_version(options.force_old_python)
timer = timers.Timer()
with timers.timing("Parsing", True):
task = pddl.open()
with timers.timing("Normalizing task"):
normalize.normalize(task)
if options.generate_relaxed_task:
# Remove delete effects.
for action in task.actions:
for index, effect in reversed(list(enumerate(action.effects))):
if effect.literal.negated:
del action.effects[index]
sas_task = pddl_to_sas(task)
dump_statistics(sas_task)
with timers.timing("Writing output"):
with open("output.sas", "w") as output_file:
sas_task.output(output_file)
print("Done! %s" % timer)
def pddl_to_sas(task):
with timers.timing("Instantiating", block=True):
relaxed_reachable, atoms, actions, axioms = instantiate.explore(task)
if not relaxed_reachable:
return unsolvable_sas_task("No relaxed solution")
# HACK! Goals should be treated differently.
if isinstance(task.goal, pddl.Conjunction):
goal_list = task.goal.parts
else:
goal_list = [task.goal]
for item in goal_list:
assert isinstance(item, pddl.Literal)
with timers.timing("Computing fact groups", block=True):
groups, mutex_groups, translation_key = fact_groups.compute_groups(
task, atoms, partial_encoding=USE_PARTIAL_ENCODING)
with timers.timing("Building STRIPS to SAS dictionary"):
ranges, strips_to_sas = strips_to_sas_dictionary(
groups, assert_partial=USE_PARTIAL_ENCODING)
with timers.timing("Building dictionary for full mutex groups"):
mutex_ranges, mutex_dict = strips_to_sas_dictionary(
mutex_groups, assert_partial=False)
if ADD_IMPLIED_PRECONDITIONS:
with timers.timing("Building implied facts dictionary..."):
implied_facts = build_implied_facts(strips_to_sas, groups, mutex_groups)
else:
implied_facts = {}
with timers.timing("Translating task", block=True):
sas_task = translate_task(
strips_to_sas, ranges, mutex_dict, mutex_ranges,
task.init, goal_list, actions, axioms, task.use_min_cost_metric,
implied_facts)
print "%d implied effects removed" % removed_implied_effect_counter
print "%d effect conditions simplified" % simplified_effect_condition_counter
print "%d implied preconditions added" % added_implied_precondition_counter
with timers.timing("Building mutex information"):
mutex_key = build_mutex_key(strips_to_sas, mutex_groups)
if DETECT_UNREACHABLE:
with timers.timing("Detecting unreachable propositions", block=True):
try:
simplify.filter_unreachable_propositions(
sas_task, mutex_key, translation_key)
except simplify.Impossible:
return unsolvable_sas_task("Simplified to trivially false goal")
with timers.timing("Writing translation key"):
write_translation_key(translation_key)
with timers.timing("Writing mutex key"):
write_mutex_key(mutex_key)
return sas_task
def main():
timer = timers.Timer()
with timers.timing("Parsing", True):
task = pddl_parser.open(task_filename=options.task, domain_filename=options.domain)
with timers.timing("Normalizing task"):
normalize.normalize(task)
compile(task)
print("Done! %s" % timer)
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):
# 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 main():
timer = timers.Timer()
with timers.timing("Parsing", True):
task = pddl_parser.open(domain_filename=options.domain,
task_filename=options.task)
with timers.timing("Normalizing task"):
normalize.normalize(task)
if options.generate_relaxed_task:
# Remove delete effects.
for action in task.actions:
for index, effect in reversed(list(enumerate(action.effects))):
if effect.literal.negated:
del action.effects[index]
# Alberto Pozanco
# Con esto guardamos el estado inicial del problema
print("ESTAMOS EJECUTANDO EL TRANSLATOR DE ALBERTO POZANCO")
#print(os.path.dirname(os.path.abspath(__file__)))
#print(os.getcwd())
#print(options.sas_file)
outfile = open('current-state.txt', 'w+')
for predicate in task.init:
if type(predicate) is pddl.f_expression.Assign:
value = predicate.expression.value
fluent = str(predicate.fluent.symbol)
args = list(predicate.fluent.args)
args2 = [str(e) for e in args]
data = '(= (' + fluent + ' ' + ' '.join(args2) + ') ' + str(
value) + ')'
outfile.write(data + '\n')
elif type(predicate) is pddl.Atom and str(predicate.predicate) != '=':
data = '(' + predicate.key[0]
for x in predicate.key[1]:
data += ' ' + str(x)
data += ')'
outfile.write(data + '\n')
elif type(predicate) is pddl.NegatedAtom:
print(
"TREMENDO FALLO DEL TRANSLATOR QUE NO HA TENIDO EN CUENTA QUE HABIA UN NEGATED ATOM"
)
outfile.close()
sas_task = pddl_to_sas(task)
dump_statistics(sas_task)
with timers.timing("Writing output"):
with open("output.sas", "w") as output_file:
sas_task.output(output_file)
print("Done! %s" % timer)
def pddl_to_sas(task):
with timers.timing("Instantiating", block=True):
(relaxed_reachable, atoms, actions, axioms,
reachable_action_params) = instantiate.explore(task)
if not relaxed_reachable:
return unsolvable_sas_task("No relaxed solution")
# HACK! Goals should be treated differently.
if isinstance(task.goal, pddl.Conjunction):
goal_list = task.goal.parts
else:
goal_list = [task.goal]
for item in goal_list:
assert isinstance(item, pddl.Literal)
with timers.timing("Computing fact groups", block=True):
groups, mutex_groups, translation_key = fact_groups.compute_groups(
task, atoms, reachable_action_params)
with timers.timing("Building STRIPS to SAS dictionary"):
ranges, strips_to_sas = strips_to_sas_dictionary(
groups, assert_partial=options.use_partial_encoding)
with timers.timing("Building dictionary for full mutex groups"):
mutex_ranges, mutex_dict = strips_to_sas_dictionary(
mutex_groups, assert_partial=False)
if options.add_implied_preconditions:
with timers.timing("Building implied facts dictionary..."):
implied_facts = build_implied_facts(strips_to_sas, groups,
mutex_groups)
else:
implied_facts = {}
with timers.timing("Building mutex information", block=True):
mutex_key = build_mutex_key(strips_to_sas, mutex_groups)
with timers.timing("Translating task", block=True):
sas_task = translate_task(
strips_to_sas, ranges, translation_key,
mutex_dict, mutex_ranges, mutex_key,
task.init, goal_list, actions, axioms, task.use_min_cost_metric,
implied_facts)
print("%d effect conditions simplified" %
simplified_effect_condition_counter)
print("%d implied preconditions added" %
added_implied_precondition_counter)
if options.filter_unreachable_facts:
with timers.timing("Detecting unreachable propositions", block=True):
try:
simplify.filter_unreachable_propositions(sas_task)
except simplify.Impossible:
return unsolvable_sas_task("Simplified to trivially false goal")
except simplify.TriviallySolvable:
return solvable_sas_task("Simplified to empty goal")
return sas_task
def pddl_to_sas(task):
with timers.timing("Instantiating", block=True):
(relaxed_reachable, atoms, actions, axioms,
reachable_action_params) = instantiate.explore(task)
if not relaxed_reachable:
return unsolvable_sas_task("No relaxed solution")
# HACK! Goals should be treated differently.
if isinstance(task.goal, pddl.Conjunction):
goal_list = task.goal.parts
else:
goal_list = [task.goal]
for item in goal_list:
assert isinstance(item, pddl.Literal)
with timers.timing("Computing fact groups", block=True):
groups, mutex_groups, translation_key = fact_groups.compute_groups(
task, atoms, reachable_action_params)
with timers.timing("Building STRIPS to SAS dictionary"):
ranges, strips_to_sas = strips_to_sas_dictionary(
groups, assert_partial=options.use_partial_encoding)
with timers.timing("Building dictionary for full mutex groups"):
mutex_ranges, mutex_dict = strips_to_sas_dictionary(
mutex_groups, assert_partial=False)
if options.add_implied_preconditions:
with timers.timing("Building implied facts dictionary..."):
implied_facts = build_implied_facts(strips_to_sas, groups,
mutex_groups)
else:
implied_facts = {}
with timers.timing("Building mutex information", block=True):
mutex_key = build_mutex_key(strips_to_sas, mutex_groups)
with timers.timing("Translating task", block=True):
sas_task = translate_task(
strips_to_sas, ranges, translation_key,
mutex_dict, mutex_ranges, mutex_key,
task.init, goal_list, actions, axioms, task.use_min_cost_metric,
implied_facts)
print("%d effect conditions simplified" %
simplified_effect_condition_counter)
print("%d implied preconditions added" %
added_implied_precondition_counter)
if options.filter_unreachable_facts:
with timers.timing("Detecting unreachable propositions", block=True):
try:
simplify.filter_unreachable_propositions(sas_task)
except simplify.Impossible:
return unsolvable_sas_task("Simplified to trivially false goal")
except simplify.TriviallySolvable:
return solvable_sas_task("Simplified to empty goal")
return sas_task
def compute_groups(task, atoms, partial_encoding=True):
groups = invariant_finder.get_groups(task)
with timers.timing("Instantiating groups"):
groups = instantiate_groups(groups, task, atoms)
# TODO: I think that collect_all_mutex_groups should do the same thing
# as choose_groups with partial_encoding=False, so these two should
# be unified.
with timers.timing("Collecting mutex groups"):
mutex_groups = collect_all_mutex_groups(groups, atoms)
with timers.timing("Choosing groups", block=True):
groups = choose_groups(groups, atoms, partial_encoding=partial_encoding)
with timers.timing("Building translation key"):
translation_key = build_translation_key(groups)
return groups, mutex_groups, translation_key
def sas_from_instantiated(instantiated_task):
import timers
import fact_groups
import options
import simplify
import variable_order
from translate import translate_task, unsolvable_sas_task, strips_to_sas_dictionary, \
build_implied_facts, build_mutex_key, solvable_sas_task
if not instantiated_task:
return unsolvable_sas_task("No relaxed solution")
task, atoms, actions, axioms, reachable_action_params, goal_list = instantiated_task
with timers.timing("Computing fact groups", block=True):
groups, mutex_groups, translation_key = fact_groups.compute_groups(
task, atoms, reachable_action_params)
with timers.timing("Building STRIPS to SAS dictionary"):
ranges, strips_to_sas = strips_to_sas_dictionary(
groups, assert_partial=options.use_partial_encoding)
with timers.timing("Building dictionary for full mutex groups"):
mutex_ranges, mutex_dict = strips_to_sas_dictionary(
mutex_groups, assert_partial=False)
if options.add_implied_preconditions:
with timers.timing("Building implied facts dictionary..."):
implied_facts = build_implied_facts(strips_to_sas, groups,
mutex_groups)
else:
implied_facts = {}
with timers.timing("Building mutex information", block=True):
mutex_key = build_mutex_key(strips_to_sas, mutex_groups)
with timers.timing("Translating task", block=True):
sas_task = translate_task(strips_to_sas, ranges, translation_key,
mutex_dict, mutex_ranges, mutex_key,
task.init, goal_list, actions, axioms,
task.use_min_cost_metric, implied_facts)
if options.filter_unreachable_facts:
with timers.timing("Detecting unreachable propositions", block=True):
try:
simplify.filter_unreachable_propositions(sas_task)
except simplify.Impossible:
return unsolvable_sas_task(
"Simplified to trivially false goal")
except simplify.TriviallySolvable:
return solvable_sas_task("Simplified to empty goal")
if options.reorder_variables or options.filter_unimportant_vars:
with timers.timing("Reordering and filtering variables", block=True):
variable_order.find_and_apply_variable_order(
sas_task, options.reorder_variables,
options.filter_unimportant_vars)
translate.dump_statistics(sas_task)
return sas_task
def compute_groups(task, atoms, reachable_action_params, partial_encoding=True):
groups = invariant_finder.get_groups(task, reachable_action_params)
with timers.timing("Instantiating groups"):
groups = instantiate_groups(groups, task, atoms)
# TODO: I think that collect_all_mutex_groups should do the same thing
# as choose_groups with partial_encoding=False, so these two should
# be unified.
with timers.timing("Collecting mutex groups"):
mutex_groups = collect_all_mutex_groups(groups, atoms)
with timers.timing("Choosing groups", block=True):
groups = choose_groups(groups, atoms, partial_encoding=partial_encoding)
with timers.timing("Building translation key"):
translation_key = build_translation_key(groups)
return groups, mutex_groups, translation_key
def compute_groups(task, atoms, actions,
reachable_action_params, partial_encoding=True,
comm = None):
invariants, groups = invariant_finder.get_groups(task, reachable_action_params)
with timers.timing("Instantiating groups"):
groups = instantiate_groups(groups, task, atoms)
if comm is not None:
# Try to instantiate another mutex groups that are based on initial
# states of other agents
#groups = ma_instantiate_groups(comm, groups, invariants, task, atoms)
# Separate private atoms to a separate groups
groups = split_groups_by_private_atoms(groups)
print('Groups split to private/public')
sys.stdout.flush()
# Split mutex groups so that all agents have the same mutex groups
# -- this should ensure that no agent have invalid mutexes.
groups = ma_split_groups(comm, groups, atoms, task.init, actions)
else:
print('NOT COMM!')
sys.stdout.flush()
print('Groups computed.')
sys.stdout.flush()
# Sort here already to get deterministic mutex groups.
groups = sort_groups(groups)
# TODO: I think that collect_all_mutex_groups should do the same thing
# as choose_groups with partial_encoding=False, so these two should
# be unified.
with timers.timing("Collecting mutex groups"):
mutex_groups = collect_all_mutex_groups(groups, atoms)
with timers.timing("Choosing groups", block=True):
groups = choose_groups(groups, atoms, partial_encoding=partial_encoding)
groups = sort_groups(groups)
with timers.timing("Building translation key"):
translation_key = build_translation_key(groups)
if DEBUG:
for group in groups:
if len(group) >= 2:
print("{%s}" % ", ".join(map(str, group)))
return groups, mutex_groups, translation_key
def translate_task(strips_to_sas, ranges, translation_key,
mutex_dict, mutex_ranges, mutex_key,
init, goals,
actions, axioms, metric, implied_facts):
with timers.timing("Processing axioms", block=True):
axioms, axiom_init, axiom_layer_dict = axiom_rules.handle_axioms(
actions, axioms, goals)
init = init + axiom_init
#axioms.sort(key=lambda axiom: axiom.name)
#for axiom in axioms:
# axiom.dump()
if options.dump_task:
# Remove init facts that don't occur in strips_to_sas: they're constant.
nonconstant_init = filter(strips_to_sas.get, init)
dump_task(nonconstant_init, goals, actions, axioms, axiom_layer_dict)
init_values = [rang - 1 for rang in ranges]
# Closed World Assumption: Initialize to "range - 1" == Nothing.
for fact in init:
pairs = strips_to_sas.get(fact, []) # empty for static init facts
for var, val in pairs:
curr_val = init_values[var]
if curr_val != ranges[var] - 1 and curr_val != val:
assert False, "Inconsistent init facts! [fact = %s]" % fact
init_values[var] = val
init = sas_tasks.SASInit(init_values)
goal_dict_list = translate_strips_conditions(goals, strips_to_sas, ranges,
mutex_dict, mutex_ranges)
if goal_dict_list is None:
# "None" is a signal that the goal is unreachable because it
# violates a mutex.
return unsolvable_sas_task("Goal violates a mutex")
assert len(goal_dict_list) == 1, "Negative goal not supported"
## we could substitute the negative goal literal in
## normalize.substitute_complicated_goal, using an axiom. We currently
## don't do this, because we don't run into this assertion, if the
## negative goal is part of finite domain variable with only two
## values, which is most of the time the case, and hence refrain from
## introducing axioms (that are not supported by all heuristics)
goal_pairs = list(goal_dict_list[0].items())
goal = sas_tasks.SASGoal(goal_pairs)
operators = translate_strips_operators(actions, strips_to_sas, ranges,
mutex_dict, mutex_ranges,
implied_facts)
axioms = translate_strips_axioms(axioms, strips_to_sas, ranges, mutex_dict,
mutex_ranges)
axiom_layers = [-1] * len(ranges)
for atom, layer in axiom_layer_dict.items():
assert layer >= 0
[(var, val)] = strips_to_sas[atom]
axiom_layers[var] = layer
variables = sas_tasks.SASVariables(ranges, axiom_layers, translation_key)
mutexes = [sas_tasks.SASMutexGroup(group) for group in mutex_key]
return sas_tasks.SASTask(variables, mutexes, init, goal,
operators, axioms, metric)
def translate_task(strips_to_sas, ranges, mutex_dict, mutex_ranges, init, goals,
actions, axioms, metric, implied_facts):
with timers.timing("Processing axioms", block=True):
axioms, axiom_init, axiom_layer_dict = axiom_rules.handle_axioms(
actions, axioms, goals)
init = init + axiom_init
#axioms.sort(key=lambda axiom: axiom.name)
#for axiom in axioms:
# axiom.dump()
init_values = [rang - 1 for rang in ranges]
# Closed World Assumption: Initialize to "range - 1" == Nothing.
for fact in init:
pair = strips_to_sas.get(fact)
pairs = strips_to_sas.get(fact, []) # empty for static init facts
for var, val in pairs:
assert init_values[var] == ranges[var] - 1, "Inconsistent init facts!"
init_values[var] = val
init = sas_tasks.SASInit(init_values)
goal_pairs = translate_strips_conditions(goals, strips_to_sas, ranges, mutex_dict, mutex_ranges).items()
goal = sas_tasks.SASGoal(goal_pairs)
operators = translate_strips_operators(actions, strips_to_sas, ranges, mutex_dict, mutex_ranges, implied_facts)
axioms = translate_strips_axioms(axioms, strips_to_sas, ranges, mutex_dict, mutex_ranges)
axiom_layers = [-1] * len(ranges)
for atom, layer in axiom_layer_dict.iteritems():
assert layer >= 0
[(var, val)] = strips_to_sas[atom]
axiom_layers[var] = layer
variables = sas_tasks.SASVariables(ranges, axiom_layers)
return sas_tasks.SASTask(variables, init, goal, operators, axioms, metric)
def translate_task(strips_to_sas, ranges, translation_key,
mutex_dict, mutex_ranges, mutex_key,
init, goals,
actions, axioms, metric, implied_facts):
with timers.timing("Processing axioms", block=True):
axioms, axiom_init, axiom_layer_dict = axiom_rules.handle_axioms(
actions, axioms, goals)
init = init + axiom_init
#axioms.sort(key=lambda axiom: axiom.name)
#for axiom in axioms:
# axiom.dump()
if DUMP_TASK:
# Remove init facts that don't occur in strips_to_sas: they're constant.
nonconstant_init = filter(strips_to_sas.get, init)
dump_task(nonconstant_init, goals, actions, axioms, axiom_layer_dict)
init_values = [rang - 1 for rang in ranges]
# Closed World Assumption: Initialize to "range - 1" == Nothing.
for fact in init:
pairs = strips_to_sas.get(fact, []) # empty for static init facts
for var, val in pairs:
curr_val = init_values[var]
if curr_val != ranges[var] - 1 and curr_val != val:
assert False, "Inconsistent init facts! [fact = %s]" % fact
init_values[var] = val
init = sas_tasks.SASInit(init_values)
goal_dict_list = translate_strips_conditions(goals, strips_to_sas, ranges,
mutex_dict, mutex_ranges)
if goal_dict_list is None:
# "None" is a signal that the goal is unreachable because it
# violates a mutex.
return unsolvable_sas_task("Goal violates a mutex")
#assert len(goal_dict_list) == 1, "Negative goal not supported"
## we could substitute the negative goal literal in
## normalize.substitute_complicated_goal, using an axiom. We currently
## don't do this, because we don't run into this assertion, if the
## negative goal is part of finite domain variable with only two
## values, which is most of the time the case, and hence refrain from
## introducing axioms (that are not supported by all heuristics)
goal_pairs = list(goal_dict_list[0].items())
goal = sas_tasks.SASGoal(goal_pairs)
operators = translate_strips_operators(actions, strips_to_sas, ranges,
mutex_dict, mutex_ranges,
implied_facts)
axioms = translate_strips_axioms(axioms, strips_to_sas, ranges, mutex_dict,
mutex_ranges)
axiom_layers = [-1] * len(ranges)
for atom, layer in axiom_layer_dict.items():
assert layer >= 0
[(var, val)] = strips_to_sas[atom]
axiom_layers[var] = layer
variables = sas_tasks.SASVariables(ranges, axiom_layers, translation_key)
mutexes = [sas_tasks.SASMutexGroup(group) for group in mutex_key]
return sas_tasks.SASTask(variables, mutexes, init, goal,
operators, axioms, metric)
def main():
timer = timers.Timer()
with timers.timing("Parsing", True):
task = pddl_parser.open(domain_filename=options.domain,
task_filename=options.task)
# print("translate.main(): task parsed\n Function symbols:")
# for fs in task.FUNCTION_SYMBOLS:
# print (fs)
# print("task is:")
# task.dump()
with timers.timing("Handling Global Constraints"):
task.add_global_constraints()
with timers.timing("Normalizing task"):
normalize.normalize(task)
# print("translate.main(): Function symbols after normalization:")
# for fs in task.FUNCTION_SYMBOLS:
# print (fs)
# print("task is:")
# task.dump()
# assert False
if options.generate_relaxed_task:
# Remove delete effects.
for action in task.actions:
for index, effect in reversed(list(enumerate(action.effects))):
if effect.literal.negated:
del action.effects[index]
sas_task = pddl_to_sas(task)
dump_statistics(sas_task)
# for operator in sas_task.operators:
# print("Operatorname = %s" % operator.name)
# print("Dumping axioms in task before writing output ")
# for axiom in sas_task.axioms:
# axiom.dump()
# avar, aval = axiom.effect
# print("Effect state value init: %s axiomresult: %s" % (avar,aval))
# print("Init = %s" % [sas_task.init.values[avar]])
with timers.timing("Writing output"):
with open("output.sas", "w") as output_file:
sas_task.output(output_file)
print("Done! %s" % timer)
def main():
timer = timers.Timer()
with timers.timing("Parsing", True):
task = pddl_parser.open(domain_filename=options.domain,
task_filename=options.task)
with timers.timing("Normalizing task"):
normalize.normalize(task)
if options.generate_relaxed_task:
# Remove delete effects.
for action in task.actions:
for index, effect in reversed(list(enumerate(action.effects))):
if effect.literal.negated:
del action.effects[index]
instantiate_dump(task)
print("Done! %s" % timer)
def compile(task):
with timers.timing("Instantiating", block=True):
(relaxed_reachable, atoms, actions, axioms,
reachable_action_params) = instantiate.explore(task)
# Transform logical terms of all cost functions into arithmetic terms.
for a in actions:
if isinstance(a.cost, pddl_parser.CostNode):
a.cost.transform_logic()
# writing value tuples to atoms
predicate_dict = dict((p.name, p ) for p in task.predicates)
for a in atoms:
p = predicate_dict.get(a.predicate)
if p and len(p.value_mapping) > 0:
a.value = p.value_mapping.get(a.args)
if not relaxed_reachable:
return unsolvable_sas_task("No relaxed solution")
# HACK! Goals should be treated differently.
if isinstance(task.goal, pddl.Conjunction):
goal_list = task.goal.parts
else:
goal_list = [task.goal]
for item in goal_list:
assert isinstance(item, pddl.Literal)
with timers.timing("Computing fact groups", block=True):
groups, mutex_groups, translation_key, atom_groups = fact_groups.compute_groups(
task, atoms, reachable_action_params)
with timers.timing("Building STRIPS to SAS dictionary"):
ranges, strips_to_sas = strips_to_sas_dictionary(
groups, assert_partial=options.use_partial_encoding)
with timers.timing("Building dictionary for full mutex groups"):
mutex_ranges, mutex_dict = strips_to_sas_dictionary(
mutex_groups, assert_partial=False)
with timers.timing("Building mutex information", block=True):
mutex_key = build_mutex_key(strips_to_sas, mutex_groups)
compiler = EVMDDActionCompiler()
actions = compiler.evmdd_action_compilation(actions)
pddl_writer = SdacPDDLWriter(compiler._fact_name_dict)
pddl_writer.write_pddl_files(options.domain, options.task, actions)
print("done!")
def compute_clusters(axioms, goals, operators):
dependencies = AxiomDependencies(axioms)
# Compute necessary literals and prune unnecessary vars from dependencies.
necessary_literals = compute_necessary_literals(dependencies, goals,
operators)
dependencies.remove_unnecessary_variables(necessary_literals)
groups = get_strongly_connected_components(dependencies)
clusters = [AxiomCluster(group) for group in groups]
# Compute mapping from variables to their clusters and set needed_negatively.
variable_to_cluster = {}
for cluster in clusters:
for variable in cluster.variables:
variable_to_cluster[variable] = cluster
if variable.negate() in necessary_literals:
cluster.needed_negatively = True
# Assign axioms to their clusters.
for axiom in axioms:
# axiom.effect is derived but might have been pruned
if axiom.effect in dependencies.derived_variables:
variable_to_cluster[axiom.effect].axioms[axiom.effect].append(
axiom)
removed = 0
with timers.timing("Simplifying axioms"):
for cluster in clusters:
for variable in cluster.variables:
old_size = len(cluster.axioms[variable])
cluster.axioms[variable] = compute_simplified_axioms(
cluster.axioms[variable])
removed += old_size - len(cluster.axioms[variable])
print("Translator axioms removed by simplifying: %d" % removed)
# Create links between clusters (positive dependencies).
for from_variable, depends_on in dependencies.positive_dependencies.items(
):
from_cluster = variable_to_cluster[from_variable]
for to_variable in depends_on:
to_cluster = variable_to_cluster[to_variable]
if from_cluster is not to_cluster:
from_cluster.positive_children.add(to_cluster)
# Create links between clusters (negative dependencies).
for from_variable, depends_on in dependencies.negative_dependencies.items(
):
from_cluster = variable_to_cluster[from_variable]
for to_variable in depends_on:
to_cluster = variable_to_cluster[to_variable]
if from_cluster is to_cluster:
raise ValueError("axioms are not stratifiable")
from_cluster.negative_children.add(to_cluster)
return clusters
def main():
options, args = parse_options()
check_python_version(options.force_old_python)
timer = timers.Timer()
with timers.timing("Parsing"):
task = pddl.open()
# EXPERIMENTAL!
# import psyco
# psyco.full()
sas_task = pddl_to_sas(task)
dump_statistics(sas_task)
with timers.timing("Writing output"):
with open("output.sas", "w") as output_file:
sas_task.output(output_file)
print("Done! %s" % timer)
def main():
options, args = parse_options()
check_python_version(options.force_old_python)
timer = timers.Timer()
with timers.timing("Parsing"):
task = pddl.open()
# EXPERIMENTAL!
# import psyco
# psyco.full()
sas_task = pddl_to_sas(task)
dump_statistics(sas_task)
with timers.timing("Writing output"):
with open("output.sas", "w") as output_file:
sas_task.output(output_file)
print("Done! %s" % timer)
def explore(task):
if DEBUG:
print("DEBUG: Exploring Task Step [1]: create logic program 'prog'")
prog = pddl_to_prolog.translate(task)
# prog.dump()
if DEBUG: print("DEBUG: Exploring Task Step [2]: build model 'model'")
model = build_model.compute_model(prog)
# print("instantiate.explore task dumps task")
# task.dump()
if DEBUG: print("DEBUG: Exploring Task Step [3]: instantiate model")
with timers.timing("Completing instantiation"):
return instantiate(task, model)
def handle_axioms(operators, axioms, goals):
axioms_by_atom = get_axioms_by_atom(axioms)
axiom_literals = compute_necessary_axiom_literals(axioms_by_atom, operators, goals)
axiom_init = get_axiom_init(axioms_by_atom, axiom_literals)
with timers.timing("Simplifying axioms"):
axioms = simplify_axioms(axioms_by_atom, axiom_literals)
axioms = compute_negative_axioms(axioms_by_atom, axiom_literals)
# NOTE: compute_negative_axioms more or less invalidates axioms_by_atom.
# Careful with that axe, Eugene!
axiom_layers = compute_axiom_layers(axioms, axiom_init)
return axioms, list(axiom_init), axiom_layers
def translate_task(strips_to_sas, ranges, mutex_dict, mutex_ranges, init, goals,
actions, axioms, metric, implied_facts):
with timers.timing("Processing axioms", block=True):
axioms, axiom_init, axiom_layer_dict = axiom_rules.handle_axioms(
actions, axioms, goals)
init = init + axiom_init
#axioms.sort(key=lambda axiom: axiom.name)
#for axiom in axioms:
# axiom.dump()
init_values = [rang - 1 for rang in ranges]
# Closed World Assumption: Initialize to "range - 1" == Nothing.
for fact in init:
pair = strips_to_sas.get(fact)
pairs = strips_to_sas.get(fact, []) # empty for static init facts
for var, val in pairs:
assert init_values[var] == ranges[var] - 1, "Inconsistent init facts!"
init_values[var] = val
init = sas_tasks.SASInit(init_values)
goal_dict_list = translate_strips_goal(goals, strips_to_sas, ranges, mutex_dict, mutex_ranges)
assert len(goal_dict_list) == 1, "Negative goal not supported"
## we could substitute the negative goal literal in
## normalize.substitute_complicated_goal, using an axiom. We currently
## don't do this, because we don't run into this assertion, if the
## negative goal is part of finite domain variable with only two
## values, which is most of the time the case, and hence refrain from
## introducing axioms (that are not supported by all heuristics)
goal_pairs = goal_dict_list[0].items()
goal = sas_tasks.SASGoal(goal_pairs)
operators = translate_strips_operators(actions, strips_to_sas, ranges, mutex_dict, mutex_ranges, implied_facts)
axioms = translate_strips_axioms(axioms, strips_to_sas, ranges, mutex_dict, mutex_ranges)
axiom_layers = [-1] * len(ranges)
for atom, layer in axiom_layer_dict.iteritems():
assert layer >= 0
[(var, val)] = strips_to_sas[atom]
axiom_layers[var] = layer
variables = sas_tasks.SASVariables(ranges, axiom_layers)
return sas_tasks.SASTask(variables, init, goal, operators, axioms, metric)
def pddl_to_sas(task, agent_id, agent_url):
comm = None
if agent_id >= 0 and len(agent_url) > 1:
comm = AgentComm(agent_id, agent_url)
with timers.timing("Instantiating", block=True):
(relaxed_reachable, atoms, actions, axioms,
reachable_action_params) = instantiate.explore(task, comm)
if not relaxed_reachable:
return unsolvable_sas_task("No relaxed solution")
# HACK! Goals should be treated differently.
if isinstance(task.goal, pddl.Conjunction):
goal_list = task.goal.parts
else:
goal_list = [task.goal]
for item in goal_list:
assert isinstance(item, pddl.Literal)
with timers.timing("Computing fact groups", block=True):
groups, mutex_groups, translation_key = fact_groups.compute_groups(
task, atoms, reachable_action_params,
partial_encoding=USE_PARTIAL_ENCODING,
comm = comm)
with timers.timing("Building STRIPS to SAS dictionary"):
ranges, strips_to_sas = strips_to_sas_dictionary(
groups, assert_partial=USE_PARTIAL_ENCODING)
if comm is not None:
# Each group contains either all public or all private values
private_vars = [x[0].is_private for x in groups]
else:
private_vars = [None for _ in groups]
with timers.timing("Building dictionary for full mutex groups"):
mutex_ranges, mutex_dict = strips_to_sas_dictionary(
mutex_groups, assert_partial=False)
if ADD_IMPLIED_PRECONDITIONS:
with timers.timing("Building implied facts dictionary..."):
implied_facts = build_implied_facts(strips_to_sas, groups,
mutex_groups)
else:
implied_facts = {}
with timers.timing("Building mutex information", block=True):
mutex_key = build_mutex_key(strips_to_sas, mutex_groups)
with timers.timing("Translating task", block=True):
sas_task = translate_task(
strips_to_sas, ranges, translation_key, private_vars,
mutex_dict, mutex_ranges, mutex_key,
task.init, goal_list, actions, axioms, task.use_min_cost_metric,
implied_facts, task.agents, comm)
print("%d effect conditions simplified" %
simplified_effect_condition_counter)
print("%d implied preconditions added" %
added_implied_precondition_counter)
if comm is not None:
comm.close()
if DETECT_UNREACHABLE and comm is None:
with timers.timing("Detecting unreachable propositions", block=True):
try:
simplify.filter_unreachable_propositions(sas_task)
except simplify.Impossible:
return unsolvable_sas_task("Simplified to trivially false goal")
return sas_task
if not rest == "":
#print "there are args" , rest
args = rest.split(",")
else:
args = []
print_line = "%d %d %s %d " % (var, val, predicate, len(args))
for arg in args:
print_line += str(arg).strip() + " "
#print fact
#print print_line
print >> invariants_file, print_line
print >> invariants_file, "end_groups"
invariants_file.close()
if __name__ == "__main__":
import pddl
timer = timers.Timer()
with timers.timing("Parsing"):
task = pddl.open()
# EXPERIMENTAL!
# import psyco
# psyco.full()
sas_task = pddl_to_sas(task)
with timers.timing("Writing output"):
sas_task.output(file("output.sas", "w"))
print "Done! %s" % timer
def pddl_to_sas(task):
# for partial observability assume that unknown facts
# are true initially (to use it in the reachability analysis)
mod_task = deepcopy(task)
mod_task.init = mod_task.init + mod_task.init_unknown
with timers.timing("Instantiating", block=True):
(relaxed_reachable, atoms, actions, observation_actions, axioms,
reachable_action_params) = instantiate.explore(mod_task)
if not relaxed_reachable:
# POND we return no unsolvable task
return
# HACK! Goals should be treated differently.
if isinstance(task.goal, pddl.Conjunction):
goal_list = task.goal.parts
else:
goal_list = [task.goal]
for item in goal_list:
assert isinstance(item, pddl.Literal)
with timers.timing("Computing fact groups", block=True):
groups, mutex_groups, translation_key = fact_groups.compute_groups(
mod_task, atoms, reachable_action_params,
partial_encoding=USE_PARTIAL_ENCODING)
with timers.timing("Building STRIPS to SAS dictionary"):
ranges, strips_to_sas = strips_to_sas_dictionary(
groups, assert_partial=USE_PARTIAL_ENCODING)
with timers.timing("Building dictionary for full mutex groups"):
mutex_ranges, mutex_dict = strips_to_sas_dictionary(
mutex_groups, assert_partial=False)
if ADD_IMPLIED_PRECONDITIONS:
with timers.timing("Building implied facts dictionary..."):
implied_facts = build_implied_facts(strips_to_sas, groups,
mutex_groups)
else:
implied_facts = {}
with timers.timing("Building mutex information", block=True):
mutex_key = build_mutex_key(strips_to_sas, mutex_groups)
with timers.timing("Translating task", block=True):
sas_task = translate_task(
strips_to_sas, ranges, translation_key,
mutex_dict, mutex_ranges, mutex_key,
task.init, task.init_unknown, task.init_oneof,
task.init_formula, goal_list, actions, observation_actions,
axioms, task.use_min_cost_metric, implied_facts)
print("%d effect conditions simplified" %
simplified_effect_condition_counter)
print("%d implied preconditions added" %
added_implied_precondition_counter)
if DETECT_UNREACHABLE:
with timers.timing("Detecting unreachable propositions", block=True):
try:
simplify.filter_unreachable_propositions(sas_task)
except simplify.Impossible:
return unsolvable_sas_task("Simplified to trivially false goal")
return sas_task
def translate_task(strips_to_sas, ranges, translation_key,
mutex_dict, mutex_ranges, mutex_key,
init, init_unknown, init_oneof, init_formula, goals,
actions, observation_actions, axioms, metric, implied_facts):
with timers.timing("Processing axioms", block=True):
axioms, axiom_init, axiom_layer_dict = axiom_rules.handle_axioms(
actions, axioms, goals)
init = init + axiom_init
#axioms.sort(key=lambda axiom: axiom.name)
#for axiom in axioms:
# axiom.dump()
if DUMP_TASK:
# Remove init facts that don't occur in strips_to_sas: they're constant.
nonconstant_init = filter(strips_to_sas.get, init)
dump_task(nonconstant_init, goals, actions, axioms, axiom_layer_dict)
# Closed World Assumption
false_facts = list(range(len(ranges)))
for fact in init_unknown:
pairs = strips_to_sas.get(fact, [])
for pair in pairs:
false_facts.remove(pair[0])
facts = []
for fact in init:
assert fact not in init_unknown
pairs = strips_to_sas.get(fact, [])
for pair in pairs:
false_facts.remove(pair[0])
if pairs:
facts = facts + pairs
for var in false_facts:
assert fact not in init_unknown
facts.append((var, ranges[var] - 1))
facts_oneof = []
for oneof in init_oneof:
assert len(oneof) >= 2
for fact in oneof:
assert fact in init_unknown
l = []
for one in oneof:
l = l + strips_to_sas.get(one, [])
facts_oneof.append(l)
# move to conditions.py?
def translate_formula(formula, result, strips_to_sas, ranges, mutex_dict, mutex_ranges):
if isinstance(formula, pddl.conditions.Atom):
assert formula in init_unknown
result.append(strips_to_sas.get(formula, []))
elif isinstance(formula, pddl.conditions.NegatedAtom):
dict_list = translate_strips_conditions([formula], strips_to_sas, ranges, mutex_dict, mutex_ranges)
assert len(dict_list) == 1
result.append(dict_list[0].items())
elif isinstance(formula, pddl.conditions.Disjunction):
result.append("or(")
for part in formula.parts:
translate_formula(part, result, strips_to_sas, ranges, mutex_dict, mutex_ranges)
result.append(")")
elif isinstance(formula, pddl.conditions.Conjunction):
result.append("and(")
for part in formula.parts:
translate_formula(part, result, strips_to_sas, ranges, mutex_dict, mutex_ranges)
result.append(")")
else:
assert False, print(formula)
formulae = []
for formula in init_formula:
result = []
translate_formula(formula, result, strips_to_sas, ranges, mutex_dict, mutex_ranges)
formulae.append(result)
init = sas_tasks.SASInit(facts, facts_oneof, formulae)
goal_dict_list = translate_strips_conditions(goals, strips_to_sas, ranges,
mutex_dict, mutex_ranges)
if goal_dict_list is None:
# "None" is a signal that the goal is unreachable because it
# violates a mutex.
return unsolvable_sas_task("Goal violates a mutex")
assert len(goal_dict_list) == 1, "Negative goal not supported"
## we could substitute the negative goal literal in
## normalize.substitute_complicated_goal, using an axiom. We currently
## don't do this, because we don't run into this assertion, if the
## negative goal is part of finite domain variable with only two
## values, which is most of the time the case, and hence refrain from
## introducing axioms (that are not supported by all heuristics)
goal_pairs = list(goal_dict_list[0].items())
goal = sas_tasks.SASGoal(goal_pairs)
operators = translate_strips_operators(actions, strips_to_sas, ranges,
mutex_dict, mutex_ranges,
implied_facts)
observation_operators = translate_strips_operators(observation_actions,
strips_to_sas, ranges,
mutex_dict, mutex_ranges,
implied_facts)
axioms = translate_strips_axioms(axioms, strips_to_sas, ranges, mutex_dict,
mutex_ranges)
axiom_layers = [-1] * len(ranges)
for atom, layer in axiom_layer_dict.items():
assert layer >= 0
[(var, val)] = strips_to_sas[atom]
axiom_layers[var] = layer
variables = sas_tasks.SASVariables(ranges, axiom_layers, translation_key)
mutexes = [sas_tasks.SASMutexGroup(group) for group in mutex_key]
return sas_tasks.SASTask(variables, mutexes, init, goal,
operators + observation_operators,
axioms, metric)
def pddl_to_sas(task):
with timers.timing("Instantiating", block=True):
(relaxed_reachable, atoms, actions, axioms,
reachable_action_params) = instantiate.explore(task)
# Transform logical terms of all cost functions into arithmetic terms.
for a in actions:
if isinstance(a.cost, pddl_parser.CostNode):
a.cost.transform_logic()
# writing value tuples to atoms
predicate_dict = dict((p.name, p ) for p in task.predicates)
for a in atoms:
p = predicate_dict.get(a.predicate)
if p and len(p.value_mapping) > 0:
a.value = p.value_mapping.get(a.args)
if not relaxed_reachable:
return unsolvable_sas_task("No relaxed solution")
# HACK! Goals should be treated differently.
if isinstance(task.goal, pddl.Conjunction):
goal_list = task.goal.parts
else:
goal_list = [task.goal]
for item in goal_list:
assert isinstance(item, pddl.Literal)
with timers.timing("Computing fact groups", block=True):
groups, mutex_groups, translation_key, atom_groups = fact_groups.compute_groups(
task, atoms, reachable_action_params)
with timers.timing("Building STRIPS to SAS dictionary"):
ranges, strips_to_sas = strips_to_sas_dictionary(
groups, assert_partial=options.use_partial_encoding)
with timers.timing("Building dictionary for full mutex groups"):
mutex_ranges, mutex_dict = strips_to_sas_dictionary(
mutex_groups, assert_partial=False)
if options.add_implied_preconditions:
with timers.timing("Building implied facts dictionary..."):
implied_facts = build_implied_facts(strips_to_sas, groups,
mutex_groups)
else:
implied_facts = {}
with timers.timing("Building mutex information", block=True):
mutex_key = build_mutex_key(strips_to_sas, mutex_groups)
if options.exp:
actions = pddl_parser.transform_exp_actions(actions, mutex_groups)
compiler = EVMDDActionCompiler()
actions = compiler.evmdd_action_compilation(actions)
pddl_writer = SdacPDDLWriter(compiler._fact_name_dict)
pddl_writer.write_pddl_files(options.domain, options.task, actions)
print("done!")
exit(0)
task.inst_actions = actions
with timers.timing("Translating task", block=True):
sas_task = translate_task(
strips_to_sas, ranges, translation_key,
mutex_dict, mutex_ranges, mutex_key,
task.init, goal_list, actions, axioms, task.use_min_cost_metric,
implied_facts, atom_groups)
print("%d effect conditions simplified" %
simplified_effect_condition_counter)
print("%d implied preconditions added" %
added_implied_precondition_counter)
if options.filter_unreachable_facts:
with timers.timing("Detecting unreachable propositions", block=True):
try:
simplify.filter_unreachable_propositions(sas_task)
except simplify.Impossible:
return unsolvable_sas_task("Simplified to trivially false goal")
except simplify.TriviallySolvable:
return solvable_sas_task("Simplified to empty goal")
atom_dict = dict((str(a), a) for a in atoms)
new_atom_groups = []
for i in range(0, len(sas_task.variables.atom_groups)):
group_str = [str(fact) for fact in sas_task.variables.atom_groups[i]]
for j in range(0, len(sas_task.variables.value_names)):
if group_str == sas_task.variables.value_names[j]:
new_atom_groups.append(sas_task.variables.atom_groups[i])
break
sas_task.variables.atom_groups = new_atom_groups
for i in range(0, len(sas_task.variables.atom_groups)):
group_str = [str(fact) for fact in sas_task.variables.atom_groups[i]]
assert(group_str == sas_task.variables.value_names[i])
# Transform atoms of all cost functions into sas notation.
# Simplify cost function
for op in sas_task.operators:
if isinstance(op.cost, pddl_parser.CostNode):
op.cost.to_sas(sas_task.variables.atom_groups, atom_dict, sas_task.variables.deleted_true_variables)
op.cost = op.cost.get_simplified_function()
return sas_task
def _explore(task, add_fluents = set()):
prog = pddl_to_prolog.translate(task, add_fluents)
model = build_model.compute_model(prog)
with timers.timing("Completing instantiation"):
return instantiate(task, model, add_fluents)
def explore(task):
prog = pddl_to_prolog.translate(task)
model = build_model.compute_model(prog)
with timers.timing("Completing instantiation"):
return instantiate(task, model)
def get_groups(task):
with timers.timing("Finding invariants"):
invariants = list(find_invariants(task))
with timers.timing("Checking invariant weight"):
result = list(useful_groups(invariants, task.init))
return result
def default( domain_file, problem_file, output_task ) :
parsing_timer = timers.Timer()
print("Domain: %s Problem: %s"%(domain_file, problem_file) )
task = pddl.open( problem_file, domain_file)
relaxed_reachable, atoms, actions, axioms, reachable_action_params = explore(task)
print("goal relaxed reachable: %s" % relaxed_reachable)
if not relaxed_reachable :
print("No weak plan exists")
sys.exit(2)
print("%d atoms" % len(atoms))
with timers.timing("Computing fact groups", block=True):
groups, mutex_groups, translation_key = fact_groups.compute_groups(
task, atoms, reachable_action_params,
partial_encoding=USE_PARTIAL_ENCODING)
index = 0
atom_table = {}
for atom in atoms :
atom.index = index
atom_table[ atom.text() ] = index
output_task.add_atom( atom.text() )
index += 1
print("Invariants %d"%len(mutex_groups))
for group in mutex_groups :
if len(group) >= 2 :
print("{%s}" % ", ".join(map(str, group)))
output_task.add_invariant( encode( group, atom_table ) )
#print( encode( group, atom_table ) )
print("Deterministic %d actions" % len(actions))
nd_actions = {}
for action in actions :
nd_action = PropositionalDetAction( action.name, action.cost )
nd_action.set_precondition( action.precondition, atom_table )
nd_action.add_effect( action.add_effects, action.del_effects, atom_table )
nd_actions[ nd_action.name ] = nd_action
index = 0
for action in nd_actions.values() :
output_task.add_action( action.name )
output_task.add_precondition( index, action.precondition )
text_prec = []
for p, v in action.precondition :
text_prec.append( "%s=%s"%(output_task.get_atom_name( p ), not v) )
for eff in action.effects :
output_task.add_effect( index, eff )
text_eff = []
for p, v in eff :
text_eff.append( "%s=%s"%(output_task.get_atom_name( p ), not v) )
index += 1
output_task.set_domain_name( task.domain_name )
output_task.set_problem_name( task.task_name )
output_task.set_init( encode( task.init, atom_table ) )
output_task.set_goal( encode( task.goal, atom_table ) )
output_task.parsing_time = parsing_timer.report()
def compute_groups(task, atoms, reachable_action_params, actions):
import mutex
import time
t = time.time()
groups = set()
for mtype in options.mutex.split('+'):
if mtype == 'fd':
g = invariant_finder.get_groups(task, reachable_action_params)
with timers.timing("Instantiating groups"):
g = instantiate_groups(g, task, atoms)
g = set([frozenset(x) for x in g])
elif mtype == 'h2':
g, _ = mutex.h2(task, atoms, actions)
elif mtype == 'fa':
g, _ = mutex.fa(task, atoms, actions)
elif mtype == 'rfa':
g, _ = mutex.rfa(task, atoms, actions)
elif mtype == 'rfa-ilp':
g, _ = mutex.fa(task, atoms, actions, rfa = True)
elif mtype == 'rfa-ilp-c':
g, _ = mutex.rfa_complete(task, atoms, actions)
elif mtype == 'extend':
g, _ = mutex.extend_mutexes(groups, task, atoms, actions)
elif mtype == 'full':
g, _ = mutex.full(task, atoms, actions, True)
elif mtype.startswith('full'):
size = int(mtype[4:])
g, _ = mutex.full(task, atoms, actions, True, size)
else:
raise Exception('Uknown mutex algorithm: ' + mtype)
g = set([x for x in g if len(x) > 1])
groups |= g
if options.mutex_max:
groups = mutex.max_mutexes(groups)
t = time.time() - t
print('MUTEX TIME:', t)
for m in groups:
print('MUTEX:', ';'.join(sorted([str(x) for x in m])))
for m in mutex.pair_mutexes(groups):
print('MUTEX2:', ';'.join(sorted([str(x) for x in m])))
# for m in mutex.max_mutexes(groups):
# print('MUTEX-MAX:', ';'.join(sorted([str(x) for x in m])))
if options.mutex_check >= 0:
check, _ = mutex.full(task, atoms, actions, True, options.mutex_check)
if check is not None:
mutex.check_mutexes(check, groups)
# Sort here already to get deterministic mutex groups.
groups = sort_groups(groups)
# TODO: I think that collect_all_mutex_groups should do the same thing
# as choose_groups with partial_encoding=False, so these two should
# be unified.
with timers.timing("Collecting mutex groups"):
mutex_groups = collect_all_mutex_groups(groups, atoms)
with timers.timing("Choosing groups", block=True):
groups = choose_groups(groups, atoms)
groups = sort_groups(groups)
with timers.timing("Building translation key"):
translation_key = build_translation_key(groups)
if DEBUG:
for group in groups:
if len(group) >= 2:
print("{%s}" % ", ".join(map(str, group)))
return groups, mutex_groups, translation_key
def fodet( domain_file, problem_file, output_task ) :
parsing_timer = timers.Timer()
print("Domain: %s Problem: %s"%(domain_file, problem_file) )
with timers.timing("Parsing", True):
task = pddl_file.open(
domain_filename=domain_file, task_filename=problem_file)
with timers.timing("Normalizing task"):
normalize.normalize(task)
relaxed_reachable, atoms, actions, axioms, reachable_action_params = explore(task)
print("goal relaxed reachable: %s" % relaxed_reachable)
if not relaxed_reachable :
print("No plan exists")
sys.exit(2)
print("%d atoms" % len(atoms))
with timers.timing("Computing fact groups", block=True):
groups, mutex_groups, translation_key = fact_groups.compute_groups(
task, atoms, reachable_action_params)
index = 0
atom_table = {}
atom_names = [ atom.text() for atom in atoms ]
atom_names.sort()
for atom in atom_names :
atom_table[ atom ] = index
output_task.add_atom( atom )
index += 1
print("Axioms %d"%len(axioms))
for axiom in axioms:
axiom.dump()
output_task.add_axiom( encode( axiom.condition, atom_table), encode( [ axiom.effect ], atom_table ))
print("Deterministic %d actions" % len(actions))
nd_actions = []
for action in actions :
#print( "action: %s cost: %d"%(action.name,action.cost) )
nd_action = PropositionalDetAction( action.name, action.cost )
nd_action.set_precondition( action.precondition, atom_table )
nd_action.add_effect( action.add_effects, action.del_effects, atom_table,atom_names, axioms )
nd_actions.append( (nd_action.name, nd_action) )
for name, _ in nd_actions.iteritems() :
output_task.add_action( name )
index = 0
for (action_name,action) in nd_actions :
output_task.add_precondition( index, action.precondition )
for eff in action.effects :
output_task.add_effect( index, eff )
#if len(action.cond_effs) != 0 :
# print action.name, len(action.cond_effs), "has conditional effects"
for cond, eff in action.cond_effs.iteritems() :
output_task.add_cond_effect( index, list(cond), eff )
output_task.set_cost( index, action.cost )
index += 1
output_task.set_domain_name( task.domain_name )
output_task.set_problem_name( task.task_name )
output_task.set_init( encode( task.init, atom_table ) )
output_task.set_goal( encode( task.goal, atom_table ) )
output_task.parsing_time = parsing_timer.report()
def default( domain_file, problem_file, output_task ) :
parsing_timer = timers.Timer()
print("Domain: %s Problem: %s"%(domain_file, problem_file) )
with timers.timing("Parsing", True):
task = pddl_file.open(
domain_filename=domain_file, task_filename=problem_file)
normalize.normalize(task)
relaxed_reachable, atoms, actions, axioms, reachable_action_params = explore(task)
print("goal relaxed reachable: %s" % relaxed_reachable)
if not relaxed_reachable :
print("No plan exists")
sys.exit(2)
print("%d atoms" % len(atoms))
with timers.timing("Computing fact groups", block=True):
groups, mutex_groups, translation_key = fact_groups.compute_groups(
task, atoms, reachable_action_params)
index = 0
atom_table = {}
atom_names = [ atom.text() for atom in atoms ]
atom_names.sort()
for atom in atom_names :
atom_table[ atom ] = index
output_task.add_atom( atom.encode('utf-8') )
index += 1
print("Axioms %d"%len(axioms))
print("Deterministic %d actions" % len(actions))
nd_actions = []
for action in actions :
#print( "action: %s cost: %d"%(action.name,action.cost) )
nd_action = PropositionalDetAction( action.name, action.cost )
nd_action.set_precondition( action.precondition, atom_table )
nd_action.add_effect( action.add_effects, action.del_effects, atom_table,atom_names, axioms )
if len(nd_action.negated_conditions) > 0 :
output_task.notify_negated_conditions( nd_action.negated_conditions )
nd_actions.append( ( nd_action.name, nd_action ) )
output_task.create_negated_fluents()
for (name, _) in nd_actions :
output_task.add_action( name.encode('utf-8') )
index = 0
for (_,action) in nd_actions :
output_task.add_precondition( index, action.precondition )
for eff in action.effects :
output_task.add_effect( index, eff )
#if len(action.cond_effs) != 0 :
# print action.name, len(action.cond_effs), "has conditional effects"
for cond, eff in action.cond_effs.iteritems() :
#print( action.name, cond, atom_names[cond[0][0]] )
output_task.add_cond_effect( index, list(cond), eff )
output_task.set_cost( index, action.cost )
index += 1
# NIR: Default options assign 0 seconds. Change Options file to 300s to have the same configuration as FD
# MRJ: Mutex groups processing needs to go after negations are compiled away
print("Invariants %d"%len(mutex_groups))
for group in mutex_groups :
if len(group) >= 2 :
#print("{%s}" % ", ".join(map(str, group)))
output_task.add_mutex_group( encode( group, atom_table ) )
#print( encode( group, atom_table ) )
output_task.set_domain_name( task.domain_name.encode('utf-8') )
output_task.set_problem_name( task.task_name.encode('utf-8') )
output_task.set_init( encode( task.init, atom_table ) )
output_task.set_goal( encode( task.goal, atom_table ) )
output_task.parsing_time = parsing_timer.report()
