def dump(task, destination=sys.stdout):
(goal_relaxed_reachable, atoms, actions, axioms,
reachable_action_params) = instantiate.explore(task)
(groups, mutex_groups,
tk) = fact_groups.compute_groups(task,
atoms,
reachable_action_params,
partial_encoding=True)
print("(:atoms", file=destination)
for atom in atoms:
print_atom(atom, destination=destination, indent=2)
print(" )", file=destination)
print("(:actions", file=destination)
for act in actions:
print(" " + act.name, file=destination)
print(" )", file=destination)
print("(:mutex-groups", file=destination)
for group in mutex_groups:
if len(group) > 1:
print_mutex_group(group, destination=destination, indent=2)
print(" )", file=destination)
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,
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, 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)
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 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 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 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 pddl_to_sas(task):
print "Instantiating..."
(relaxed_reachable, atoms, num_fluents, actions, durative_actions, axioms,
num_axioms, reachable_action_params) = instantiate.explore(task)
if not relaxed_reachable:
return unsolvable_sas_task("No relaxed solution")
num_axioms = list(num_axioms)
num_axioms.sort(lambda x, y: cmp(x.name, y.name))
# HACK! Goals should be treated differently (see TODO file).
# Update: This is now done during normalization. The assertions
# are only left here to be on the safe side. Can be removed eventually
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)
groups, mutex_groups, translation_key = fact_groups.compute_groups(
task,
atoms,
reachable_action_params,
return_mutex_groups=WRITE_ALL_MUTEXES,
partial_encoding=USE_PARTIAL_ENCODING,
safe=USE_SAFE_INVARIANT_SYNTHESIS)
num_axioms_by_layer, max_num_layer, num_axiom_map, const_num_axioms = \
numeric_axiom_rules.handle_axioms(num_axioms)
print "Building STRIPS to SAS dictionary..."
ranges, strips_to_sas = strips_to_sas_dictionary(groups, num_axioms,
num_axiom_map,
num_fluents)
print "Translating task..."
assert not actions, "There shouldn't be any actions - just temporal actions"
sas_task = translate_task(strips_to_sas, ranges, task.init, goal_list,
actions, durative_actions, axioms, num_axioms,
num_axioms_by_layer, max_num_layer,
num_axiom_map, const_num_axioms)
simplify.constrain_end_effect_conditions(sas_task)
mutex_key = build_mutex_key(strips_to_sas, mutex_groups)
# try:
# simplify.filter_unreachable_propositions(
# sas_task, mutex_key, translation_key)
# except simplify.Impossible:
# return unsolvable_sas_task("Simplified to trivially false goal")
write_translation_key(strips_to_sas)
if WRITE_ALL_MUTEXES:
write_mutex_key(mutex_key)
return sas_task
def pddl_to_sas_lite(task, actions, relaxed_reachable, atoms, axioms,
reachable_action_params):
# HACK! Goals should be treated differently.
if isinstance(task.goal, pddl.Conjunction):
goal_list = task.goal.parts
else:
goal_list = [task.goal]
#print ("Goals "+str(goal_list))
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)
#print ("Goals init "+str(sas_task.init.values))
#print ("Goals pair "+str(sas_task.goal.pairs))
if options.filter_unreachable_facts:
with timers.timing("Detecting unreachable propositions", block=True):
try:
simplify.filter_unreachable_propositions(sas_task)
except simplify.Impossible:
#print ("Goals IMPOSSIBLE")
return unsolvable_sas_task(
"Simplified to trivially false goal")
#print ("Goals pair "+str(sas_task.goal.pairs))
return sas_task
def pddl_to_sas(task):
print "Instantiating..."
(relaxed_reachable, atoms, num_fluents, actions,
durative_actions, axioms, num_axioms) = instantiate.explore(task)
if not relaxed_reachable:
return unsolvable_sas_task("No relaxed solution")
num_axioms = list(num_axioms)
num_axioms.sort(lambda x,y: cmp(x.name,y.name))
# HACK! Goals should be treated differently (see TODO file).
# Update: This is now done during normalization. The assertions
# are only left here to be on the safe side. Can be removed eventually
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)
groups, mutex_groups, translation_key = fact_groups.compute_groups(
task, atoms, return_mutex_groups=WRITE_ALL_MUTEXES,
partial_encoding=USE_PARTIAL_ENCODING)
num_axioms_by_layer, max_num_layer, num_axiom_map, const_num_axioms = \
numeric_axiom_rules.handle_axioms(num_axioms)
print "Building STRIPS to SAS dictionary..."
ranges, strips_to_sas = strips_to_sas_dictionary(groups, num_axioms, num_axiom_map, num_fluents)
print "Translating task..."
sas_task = translate_task(strips_to_sas, ranges, task.init, goal_list,
actions, durative_actions, axioms, num_axioms,
num_axioms_by_layer, max_num_layer, num_axiom_map,
const_num_axioms)
simplify.constrain_end_effect_conditions(sas_task)
mutex_key = build_mutex_key(strips_to_sas, mutex_groups)
# try:
# simplify.filter_unreachable_propositions(
# sas_task, mutex_key, translation_key)
# except simplify.Impossible:
# return unsolvable_sas_task("Simplified to trivially false goal")
write_translation_key(strips_to_sas)
if WRITE_ALL_MUTEXES:
write_mutex_key(mutex_key)
return sas_task
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 pddl_to_sas(task):
print "Instantiating..."
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 (see TODO file).
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)
groups, mutex_groups, translation_key = fact_groups.compute_groups(
task,
atoms,
return_mutex_groups=WRITE_ALL_MUTEXES,
partial_encoding=USE_PARTIAL_ENCODING)
print "Building STRIPS to SAS dictionary..."
ranges, strips_to_sas = strips_to_sas_dictionary(groups)
print "Translating task..."
sas_task = translate_task(strips_to_sas, ranges, task.init, goal_list,
actions, axioms, task.use_min_cost_metric)
mutex_key = build_mutex_key(strips_to_sas, mutex_groups)
try:
simplify.filter_unreachable_propositions(sas_task, mutex_key,
translation_key)
except simplify.Impossible:
return unsolvable_sas_task("Simplified to trivially false goal")
write_translation_key(translation_key)
if WRITE_ALL_MUTEXES:
write_mutex_key(mutex_key)
return sas_task
def pddl_to_sas(task):
print "Instantiating..."
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 (see TODO file).
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)
groups, mutex_groups, translation_key = fact_groups.compute_groups(
task, atoms, return_mutex_groups=WRITE_ALL_MUTEXES,
partial_encoding=USE_PARTIAL_ENCODING)
print "Building STRIPS to SAS dictionary..."
ranges, strips_to_sas = strips_to_sas_dictionary(groups)
print "Translating task..."
sas_task = translate_task(strips_to_sas, ranges, task.init, goal_list,
actions, axioms, task.use_min_cost_metric)
mutex_key = build_mutex_key(strips_to_sas, mutex_groups)
try:
simplify.filter_unreachable_propositions(
sas_task, mutex_key, translation_key)
except simplify.Impossible:
return unsolvable_sas_task("Simplified to trivially false goal")
write_translation_key(translation_key)
if WRITE_ALL_MUTEXES:
write_mutex_key(mutex_key)
return sas_task
def fodet(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)
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,
partial_encoding=USE_PARTIAL_ENCODING)
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)
nd_actions[nd_action.name] = nd_action
for name, _ in nd_actions.iteritems():
output_task.add_action(name)
index = 0
for action in nd_actions.values():
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 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):
if options.use_partial_encoding:
mutex_key = build_mutex_key(strips_to_sas, mutex_groups)
else:
# With our current representation, emitting complete mutex
# information for the full encoding can incur an
# unacceptable (quadratic) blowup in the task representation
# size. See issue771 for details.
print(
"using full encoding: between-variable mutex information skipped."
)
mutex_key = []
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")
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)
return sas_task
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 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 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()
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, inessentials = fact_groups.compute_groups(
task, atoms, reachable_action_params, actions, axioms)
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")
reachable_inessentials = []
for i, values in enumerate(sas_task.variables.value_names):
if len(values) > 2:
continue
pos, neg = values
for mutex in inessentials:
if (pos == str(mutex)):
reachable_inessentials.append(mutex)
if options.mark_inessential:
sas_task.variables.axiom_layers[i] = -2
print("Translator essentials: {}".format(
len(sas_task.variables.ranges) - len(reachable_inessentials)))
print("Translator inessentials: {}".format(len(reachable_inessentials)))
return sas_task
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 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()
def pddl_to_sas(task):
with timers.timing("Instantiating", block=True):
(relaxed_reachable, atoms, num_fluents, actions, axioms, num_axioms,
init_constant_predicates, init_constant_numerics,
reachable_action_params) = instantiate.explore(task)
if DEBUG: print("Task converted to SAS.")
# task.function_administrator.dump()
if DEBUG: print("Relaxed_reachable: %s" % relaxed_reachable)
if DEBUG: print("List of %d Atoms:" % len(atoms))
# for atom in atoms:
# atom.dump()
if DEBUG: print("List of %d numeric Fluents:" % len(num_fluents))
# for fluent in num_fluents:
# fluent.dump()
if len(num_fluents) == 0:
assert False
if DEBUG: print("List of %d Actions:" % len(actions))
# for action in actions:
# print(action.name)
if DEBUG: print("List of %d propositional Axioms:" % len(axioms))
# if len(axioms) > 0:
# axioms[0].dump()
# print("layer=%s"%axioms[0].__class__ )
# for axiom in axioms:
# axiom.dump()
if DEBUG: print("List of %d numeric Axioms:" % len(num_axioms))
# for numax in num_axioms:
# numax.dump()
if DEBUG:
print("List of %d constant predicates from initial state" %
len(init_constant_predicates))
# for icp in init_constant_predicates:
# icp.dump()
if DEBUG:
print("List of %d constant numeric predicates from initial state" %
len(init_constant_numerics))
# for icn in init_constant_numerics:
# icn.dump()
if DEBUG:
print("List of %d reachable Action Parameters:" %
len(reachable_action_params))
# for rap in reachable_action_params:
# rap.dump()
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)
assert isinstance(task.global_constraint, pddl.Literal)
# if DEBUG: print("Global constraint Literal is ", task.global_constraint)
with timers.timing("Computing fact groups", block=True):
# groups: the ground facts are grouped in order to create multi valued variables
# mutex_groups: includes all mutex groups, so a fact can appear in multiple groups
# translation key: the names of the grounded facts of the MVV determined in groups, including "NegatedAtom" for binary and "none of those" for multi valued variables
groups, mutex_groups, translation_key = fact_groups.compute_groups(
task, atoms, reachable_action_params)
# print ("Fact groups (%d) computed %s" % (len(groups),[len(group) for group in groups]))
# print ("Full mutex groups (%d) containing %s:" % (len(mutex_groups),[len(group) for group in mutex_groups]))
with timers.timing("Handling numeric axioms"):
num_axioms_by_layer, max_num_layer, num_axiom_map, const_num_axioms = \
numeric_axiom_rules.handle_axioms(num_axioms)
with timers.timing("Building STRIPS to SAS dictionary"):
ranges, strips_to_sas, num_count, numeric_strips_to_sas = strips_to_sas_dictionary(
groups,
num_axioms,
num_axiom_map,
num_fluents,
assert_partial=options.use_partial_encoding)
# if DEBUG:
# print("Strips to sas dictionary (%s entries)" % len(strips_to_sas))
# for entry in sorted(strips_to_sas.items(), key=lambda x:x[1]): # sort by value
# print("%s -> %s" % entry)
# print(ranges)
# print("Numeric Strips to sas dictionary (%s entries)" % len(numeric_strips_to_sas))
# for entry in numeric_strips_to_sas:
# print("%s -> %s" % (entry, numeric_strips_to_sas[entry]))
# print ("pddl2sas Zwischendebug: metric = ", task.metric)
# assert task.metric[1] in numeric_strips_to_sas
with timers.timing("Building dictionary for full mutex groups"):
mutex_ranges, mutex_dict, _, _ = strips_to_sas_dictionary(
mutex_groups,
num_axioms,
num_axiom_map,
num_fluents,
assert_partial=False,
include_numeric=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, numeric_strips_to_sas,
num_count, mutex_dict, mutex_ranges, mutex_key, task.init,
task.num_init, goal_list, task.global_constraint, actions, axioms,
num_axioms, num_axioms_by_layer, num_axiom_map, const_num_axioms,
task.metric, implied_facts, init_constant_predicates,
init_constant_numerics)
# print("len(variables.valuenames) = %s" % len(sas_task.variables.value_names))
print("%d effect conditions simplified" %
simplified_effect_condition_counter)
print("%d implied preconditions added" %
added_implied_precondition_counter)
# print("created sas_task")
# sas_task.dump()
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")
# print("translate pddl to sas returns task")
return sas_task
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
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
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)
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,
partial_encoding=USE_PARTIAL_ENCODING)
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("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)
if len(nd_action.negated_conditions) > 0:
output_task.notify_negated_conditions(nd_action.negated_conditions)
nd_actions[nd_action.name] = nd_action
output_task.create_negated_fluents()
for name, _ in nd_actions.iteritems():
output_task.add_action(name)
index = 0
for action in nd_actions.values():
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
# 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)
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 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")
# ALBERTO POZANCO
# Here we write the static predicates
outfile = open('static-predicates.txt', 'w+')
for a in task.init:
if type(a) is pddl.Atom and str(a.predicate) != '=':
if a not in atoms:
data = '(' + a.key[0]
for x in a.key[1]:
data += ' ' + str(x)
data += ')'
outfile.write(data + '\n')
outfile.close()
# 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")
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)
return sas_task
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)
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,
partial_encoding=USE_PARTIAL_ENCODING)
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("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 )
if len(nd_action.negated_conditions) > 0 :
output_task.notify_negated_conditions( nd_action.negated_conditions )
nd_actions[ nd_action.name ] = nd_action
output_task.create_negated_fluents()
for name, _ in nd_actions.iteritems() :
output_task.add_action( name )
index = 0
for action in nd_actions.values() :
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
# 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 )
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 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")
goal_list = translate_to_list(task.goal)
online_goals_list = [translate_to_list(subgoal) for subgoal in task.online_goals]
online_goals_availability = task.online_goals_availability
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, online_goals_list, online_goals_availability, actions, axioms, task.use_min_cost_metric,
task.execution_time, 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")
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)
return sas_task
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 pddl_to_sas(task):
print "Instantiating..."
(relaxed_reachable, atoms, num_fluents, actions,
durative_actions, axioms, num_axioms, modules,
init_constant_predicates, init_constant_numerics,
reachable_action_params) = instantiate.explore(task)
# make order deterministic
init_constant_predicates = list(init_constant_predicates)
init_constant_predicates.sort(lambda x,y: cmp(str(x), str(y)))
init_constant_numerics = list(init_constant_numerics)
init_constant_numerics.sort(lambda x,y: cmp(str(x), str(y)))
if not relaxed_reachable:
return unsolvable_sas_task("No relaxed solution")
axioms = list(axioms)
axioms.sort(lambda x,y: cmp(str(x), str(y)))
num_axioms = list(num_axioms)
num_axioms.sort(lambda x,y: cmp(x.name,y.name))
# HACK! Goals should be treated differently.
# Update: This is now done during normalization. The assertions
# are only left here to be on the safe side. Can be removed eventually
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)
groups, mutex_groups, translation_key = fact_groups.compute_groups(
task, atoms, reachable_action_params,
return_mutex_groups=WRITE_ALL_MUTEXES,
partial_encoding=USE_PARTIAL_ENCODING,
safe=USE_SAFE_INVARIANT_SYNTHESIS)
num_axioms_by_layer, max_num_layer, num_axiom_map, const_num_axioms = \
numeric_axiom_rules.handle_axioms(num_axioms)
print "Building STRIPS to SAS dictionary..."
ranges, strips_to_sas, module_effects_to_sas, module_groundings_to_sas = strips_to_sas_dictionary(groups, num_axioms, num_axiom_map, num_fluents, modules)
print "Translating task..."
assert not actions, "There shouldn't be any actions - just temporal actions"
sas_task = translate_task(strips_to_sas, module_effects_to_sas, module_groundings_to_sas, ranges, task.init, goal_list,
actions, durative_actions, axioms, num_axioms,
num_axioms_by_layer, max_num_layer, num_axiom_map,
const_num_axioms, task.oplinit, task.objects, modules, task.module_inits, task.module_exits, task.subplan_generators, init_constant_predicates, init_constant_numerics)
simplify.constrain_end_effect_conditions(sas_task)
mutex_key = build_mutex_key(strips_to_sas, mutex_groups)
# try:
# simplify.filter_unreachable_propositions(
# sas_task, mutex_key, translation_key)
# except simplify.Impossible:
# return unsolvable_sas_task("Simplified to trivially false goal")
write_translation_key(strips_to_sas)
if WRITE_ALL_MUTEXES:
write_mutex_key(mutex_key)
return sas_task
