def recover_axioms_plans(instantiated, action_instances):
#axioms, axiom_init, _ = axiom_rules.handle_axioms(
# instantiated.actions, instantiated.axioms, instantiated.goal_list)
new_action_instances = [
copy.deepcopy(instance) for instance in action_instances
]
axioms, axiom_init = instantiated.axioms, [
] # TODO: bug when needing to reachieve negated
axioms_from_effect = defaultdict(list)
for axiom in axioms:
axioms_from_effect[axiom.effect].append(axiom)
axioms_from_name = get_derived_predicates(instantiated.task.axioms)
state = set(instantiated.task.init) | set(axiom_init)
axiom_plans = []
for action in new_action_instances + [
get_goal_instance(instantiated.task.goal)
]:
all_conditions = list(get_precondition(action)) + list(
flatten(cond
for cond, _ in action.add_effects + action.del_effects))
axioms = backtrack_axioms(all_conditions, axioms_from_effect, set())
axiom_from_atom, _ = get_achieving_axioms(state, axioms)
action.applied_effects = []
for effects in [action.add_effects, action.del_effects]:
negate = (effects is action.del_effects)
for i, (conditions, effect) in reversed(list(enumerate(effects))):
if all(
literal_holds(state, literal) or (
literal in axiom_from_atom)
for literal in conditions):
action.precondition.extend(conditions)
effects[i] = ([], effect)
action.applied_effects.append(
effect.negate() if negate else effect)
else:
effects.pop(i)
# RuntimeError: Preimage fact ('new-axiom@0',) is not achievable!
#precondition = action.precondition # TODO: strange bug if this applies
precondition = [
literal for literal in action.precondition
if literal.predicate in axioms_from_name
]
axiom_plans.append([])
success = extract_axioms(state, axiom_from_atom, precondition,
axiom_plans[-1])
if not success:
print(all_conditions)
print(action)
print(axioms)
raise RuntimeError('Could not extract axioms')
apply_action(state, action)
return new_action_instances, axiom_plans
def reinstantiate_action_instances(task, old_instances, **kwargs):
# Recomputes the instances with without any pruned preconditions
state = set(task.init)
new_instances = []
for old_instance in old_instances:
# TODO: better way of instantiating conditional effects (when not fluent)
new_instance = reinstantiate_action(state, old_instance, **kwargs)
assert (new_instance is not None)
new_instances.append(new_instance)
apply_action(state, new_instance)
new_instances.append(get_goal_instance(task.goal)) # TODO: move this?
return new_instances
def recover_axioms_plans2(instantiated, action_instances):
#import axiom_rules
#with Verbose(False):
# normalized_axioms, axiom_init, axiom_layer_dict = axiom_rules.handle_axioms(
# [], instantiated.axioms, instantiated.goal_list)
#state = set(instantiated.task.init + axiom_init)
normalized_axioms = instantiated.axioms # TODO: ignoring negated because cannot reinstantiate correctly
state = set(instantiated.task.init)
fluents = get_fluents(state, action_instances)
unprocessed_from_atom = defaultdict(list)
fluents_from_axiom = {}
remaining_from_axiom = {}
for axiom in normalized_axioms:
fluent_conditions = []
for literal in axiom.condition:
if literal.positive() in fluents:
fluent_conditions.append(literal)
elif not literal_holds(state, literal):
fluent_conditions = None
break
if fluent_conditions is None:
continue
for literal in fluent_conditions:
unprocessed_from_atom[literal].append(axiom)
fluents_from_axiom[id(axiom)] = len(fluent_conditions)
remaining_from_axiom[id(axiom)] = fluents_from_axiom[id(axiom)]
static_axioms = [
axiom for axiom, num in fluents_from_axiom.items() if num == 0
]
axiom_plans = []
for action in action_instances + [
get_goal_instance(instantiated.task.goal)
]:
axiom_from_atom = mark_iteration(state, unprocessed_from_atom,
fluents_from_axiom,
remaining_from_axiom, static_axioms)
preimage = []
for literal in action.precondition:
if not literal_holds(state, literal):
preimage.append(literal)
assert literal in axiom_from_atom
for cond, eff in (action.add_effects + action.del_effects):
# TODO: add conditional effects that must hold here
assert not cond
axiom_plans.append([])
assert extract_axioms(axiom_from_atom, preimage, axiom_plans[-1])
apply_action(state, action)
return axiom_plans
def recover_axioms_plans(instantiated, action_instances):
#axioms, axiom_init, _ = axiom_rules.handle_axioms(
# instantiated.actions, instantiated.axioms, instantiated.goal_list)
axioms, axiom_init = instantiated.axioms, [
] # TODO: bug when needing to reachieve negated
axioms_from_effect = defaultdict(list)
for axiom in axioms:
axioms_from_effect[axiom.effect].append(axiom)
state = set(instantiated.task.init) | set(axiom_init)
axiom_plans = []
for action in action_instances + [
get_goal_instance(instantiated.task.goal)
]:
all_conditions = list(get_precondition(action)) + list(
flatten(cond
for cond, _ in action.add_effects + action.del_effects))
axioms = backtrack_axioms(all_conditions, axioms_from_effect, set())
axiom_from_atom, _ = get_achieving_axioms(state, axioms)
action.applied_effects = []
for effects in [action.add_effects, action.del_effects]:
negate = effects is action.del_effects
for i, (conditions, effect) in reversed(list(enumerate(effects))):
if all(
literal_holds(state, literal) or (
literal in axiom_from_atom)
for literal in conditions):
action.precondition.extend(conditions)
effects[i] = ([], effect)
action.applied_effects.append(
effect.negate() if negate else effect)
else:
effects.pop(i)
axiom_plans.append([])
assert extract_axioms(state, axiom_from_atom, action.precondition,
axiom_plans[-1])
apply_action(state, action)
return axiom_plans