def extraction_helper(state,
instantiated_axioms,
goals,
negative_from_name={}):
# TODO: filter instantiated_axioms that aren't applicable?
with Verbose(False):
helpful_axioms, axiom_init, _ = axiom_rules.handle_axioms(
[], instantiated_axioms, goals)
axiom_init = set(axiom_init)
axiom_effects = {axiom.effect for axiom in helpful_axioms}
#assert len(axiom_effects) == len(axiom_init)
for pre in list(goals) + list(axiom_effects):
if pre.positive() not in axiom_init:
axiom_init.add(pre.positive().negate())
goal_action = pddl.PropositionalAction(GOAL_NAME, goals, [], None)
axiom_from_atom, _ = get_achieving_axioms(state | axiom_init,
helpful_axioms + [goal_action],
negative_from_name)
axiom_plan = [] # Could always add all conditions
success = extract_axioms(state | axiom_init, axiom_from_atom, goals,
axiom_plan, negative_from_name)
if not success:
print('Warning! Could not extract an axiom plan')
#return None
return axiom_plan
def replace_derived(task, negative_init, action_instances):
import pddl_to_prolog
import build_model
import axiom_rules
import pddl
original_actions = task.actions
original_init = task.init
task.actions = []
function_assignments = {f.fluent: f.expression for f in task.init
if isinstance(f, pddl.f_expression.FunctionAssignment)}
task.init = (set(task.init) | {a.negate() for a in negative_init}) - set(function_assignments)
for instance in action_instances:
#axiom_plan = extract_axiom_plan(task, instance, negative_from_name={}) # TODO: refactor this
# TODO: just instantiate task?
with Verbose(False):
model = build_model.compute_model(pddl_to_prolog.translate(task)) # Changes based on init
# fluent_facts = instantiate.get_fluent_facts(task, model)
fluent_facts = MockSet()
instantiated_axioms = instantiate_axioms(model, task.init, fluent_facts)
goal_list = [] # TODO: include the goal?
with Verbose(False): # TODO: helpful_axioms prunes axioms that are already true (e.g. not Unsafe)
helpful_axioms, axiom_init, _ = axiom_rules.handle_axioms([instance], instantiated_axioms, goal_list)
axiom_from_atom, _ = get_achieving_axioms(task.init | negative_init | set(axiom_init), helpful_axioms)
# negated_from_name=negated_from_name)
axiom_plan = []
extract_axioms(axiom_from_atom, instance.precondition, axiom_plan)
substitute_derived(axiom_plan, instance)
assert(is_applicable(task.init, instance))
apply_action(task.init, instance)
task.actions = original_actions
task.init = original_init
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 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
