def not_equal_stream(ty1=OBJECT, ty2=OBJECT):
name = '_not_eq_%s_%s' % (ty1.name, ty2.name)
AreNotEqual = NamedPredicate(name, [ty1, ty2])
X1, X2 = Parameter('x1', ty1), Parameter('x2', ty2)
cs = EasyTestStream([X1, X2], [], [AreNotEqual(X1, X2)],
lambda x1, x2: x1 != x2, eager=True)
return AreNotEqual, cs
def rename_easy(assignments):
"""
Mutates any :class:`.EasyType`, :class:`.EasyPredicate`, or :class:`.EasyParameter` instance to assign their local scope name
:param assignments: the result of ```locals()```
"""
for name, value in assignments.iteritems():
if type(value) in [EasyType, EasyPredicate]:
value.name = name.lower()
elif type(value) == EasyParameter:
Parameter.__init__(value, name, value.type)
def p1(self):
return Parameter('1', self) # NOTE - could also just make an object
hand_empty = H(0)
holding_1 = H(1)
Function = Predicate # TODO - alternatively a constraint
Kin = Function('kin', [R, O])
Motion = Function('motion', [R, R, T])
# TODO - make a shared initial and final variable for all of these
# I could just make a long laundry list of fluents that are constraints
# NOTE - if I list a variable twice, then I have to automatically substitute its values
# Maybe list what changes instead fo what is the same in general
Q = Parameter('q', R)
QE = Parameter('qe', R)
Q1 = Parameter('q1', R)
Q2 = Parameter('q2', R)
def O1(name):
return 'o' + name + '1'
def B(var):
return var + 'e'
def E(var):
def convert_axioms_to_effects(self):
derived_predicates = self.get_derived_predicates()
fluent_predicates = self.get_fluent_predicates()
constants = defaultdict(set)
for const in self.get_constants():
constants[const.type].add(const)
mapping = []
for op in self.operators:
if isinstance(op, Axiom):
[conditions
] = op.condition.dequantify(constants).get_literals()
assert not filter(lambda a: a.predicate in derived_predicates,
conditions)
print conditions
[fluent] = filter(lambda a: a.predicate in fluent_predicates,
conditions)
others = filter(lambda a: a != fluent, conditions)
mapping.append((fluent, others, op.effect))
new_operators = []
for op in self.operators:
if isinstance(op, Action):
new_op = op.clone()
new_operators.append(new_op)
[literals] = new_op.effect.get_literals()
for literal in literals:
effect = literal.formula if isinstance(literal,
Not) else literal
for fluent, conditions, derived in mapping:
if effect.predicate == fluent.predicate:
free_params = set(
flatten(
map(lambda a: a.args, [derived] +
conditions))) - set(fluent.args)
param_map = dict(zip(fluent.args, effect.args))
for i, param in enumerate(free_params):
param_map[param] = Parameter(
'l%s' % i, param.type)
new_params = list(
set(param_map.values()) - set(effect.args))
new_derived = derived.instantiate(param_map)
new_conditions = [
cond.instantiate(param_map)
for cond in conditions
]
if isinstance(literal, Not):
new_op.add_effects(
ForAll(
new_params,
When(And(*new_conditions),
new_derived)))
else:
new_op.add_effects(
ForAll(
new_params,
When(And(*new_conditions),
Not(new_derived))))
return new_operators
def convert_axioms_to_effects(
problem
): # NOTE - can always use the previous compilation process for some problematic axioms
derived_predicates = problem.get_derived_predicates()
fluent_predicates = problem.get_fluent_predicates()
constants = defaultdict(set)
for const in problem.get_constants():
constants[const.type].add(const)
mapping = []
for op in problem.operators: # NOTE - can always just convert one
if isinstance(op, Axiom):
[conditions] = op.condition.dequantify(constants).get_literals(
) # TODO - more complicated if multiple ways to achieve
assert not filter(
lambda a: a.predicate in derived_predicates,
conditions) # TODO - difficulty when levels of axioms
print conditions
[fluent] = filter(
lambda a: a.predicate in fluent_predicates,
conditions) # NOTE - could easily expand to conjunctive case
others = filter(lambda a: a != fluent, conditions)
mapping.append((fluent, others, op.effect))
new_operators = []
for op in problem.operators:
if isinstance(op, Action):
new_op = op.clone()
new_operators.append(new_op)
[literals] = new_op.effect.get_literals() # TODO
for literal in literals:
effect = literal.formula if isinstance(literal,
Not) else literal
for fluent, conditions, derived in mapping:
if effect.predicate == fluent.predicate:
free_params = set(
flatten(
map(lambda a: a.args, [derived] +
conditions))) - set(fluent.args)
param_map = dict(zip(fluent.args, effect.args))
for i, param in enumerate(
free_params): # Prevents conflicting names
#param_map[param] = Parameter('_%s'%i, param.type) # NOTE - FF can't parse this
param_map[param] = Parameter('l%s' % i, param.type)
new_params = list(
set(param_map.values()) - set(effect.args))
new_derived = derived.instantiate(param_map)
new_conditions = [
cond.instantiate(param_map) for cond in conditions
] # TODO - could put in the negated version of new_derived
if isinstance(literal, Not):
new_op.add_effects(
ForAll(new_params,
When(And(*new_conditions),
new_derived)))
else:
new_op.add_effects(
ForAll(
new_params,
When(And(*new_conditions),
Not(new_derived)))
) # Not necessary, but it could reduce the number of instances
#op.add_effects(ForAll(new_params, Not(new_derived))) # One failure can break
return new_operators