def __to_python_formula(formula):
formula = Util.endecode_string(formula, encode_pair_logic[0],
encode_pair_logic[1])
formula = formula.replace('=', '==')
formula = Util.endecode_string(formula, encode_pair_logic[1],
encode_pair_logic[0])
return formula.replace('!', ' not ').replace('&',
' and ').replace('|', ' or ')
def __get_ispl_formula(formula, model, fluent_tuple_list): #print formula ispl_fluent_list = ['%s%s'%(f,'_'.join(para_list)) for f, para_list, sort in fluent_tuple_list] fluent_list = ['%s(%s)'%(f,','.join(para_list)) for f, para_list, sort in fluent_tuple_list] pred_fluent_list = ['%s(%s)'%(f,','.join(para_list)) for f, para_list, sort in fluent_tuple_list \ if f in context_operator.get_predicates()] formula = Formula.transform_entailment(formula) formula = ____add_env(formula, fluent_list) #print formula formula = Formula.grounding(formula, model) #print formula formula = ____ispl_simplify(formula, 'Environment.Action') #print formula formula = ____to_ispl_preds(formula, pred_fluent_list) #print formula #formula = ____add_env(formula, fluent_list) #print formula formula = Util.endecode_string(formula, fluent_list, ispl_fluent_list) #print formula formula = ____to_ispl_logic(formula) #print formula #print return formula
def transform_entailment(formula):
old_formula = ""
while old_formula != formula:
old_formula = formula
formula = Util.repeat_replace_inner_with_pattern(
quantifier_pattern, __mrepl_entailment_quantifier, old_formula)
return Util.endecode_string(__eliminate_bracket(formula), encode_pair[1],
encode_pair[0])
def ____add_sort_forall(rule_list):
for e, rule in enumerate(rule_list):
new_formula = Util.repeat_replace_inner_with_pattern(
addsort_pattern, ______mrepl_addsort_forall, rule[2])
new_formula = Util.endecode_string(new_formula,
Util.encode_pair_forall[1],
Util.encode_pair_forall[0])
rule_list[e] = (rule[0], rule[1], new_formula)
return rule_list
def ______mrepl_addsort_forall(matched):
sort_dict = context_operator.get_symbol_sorts_dict()
var_list = matched.group("var").split(",")
var_sort_list = [var + ":" + sort_dict[var] for var in var_list]
var_sort_str = ",".join(var_sort_list)
var_sort_str = matched.group(
"head") + "(" + var_sort_str + ")" + matched.group('body')
return Util.endecode_string(var_sort_str, Util.encode_pair_forall[0],
Util.encode_pair_forall[1])
def __normalize_formula(formula): encoded_normal_str = Util.repeat_replace_inner_with_pattern(forall_pattern, __mrepl_handle_forall, formula) context_operator.use_local_dict() encoded_normal_str = __normalize_fluents(encoded_normal_str) add_formula = __get_formula_from_local_dict() #add_formula = Util.endecode_string(add_formula, Util.encode_pair[1], Util.encode_pair[0]) #--(***)--- encoded_normal_str = add_formula+ "&( " + encoded_normal_str + ")}" if add_formula!="" else encoded_normal_str normal_str = Util.endecode_string(encoded_normal_str,encode_pair_forall[1],encode_pair_forall[0]) return normal_str
def __mrepl_handle_forall(matched):
context_operator.use_local_dict() # a dict to store { fluent: var}
encoded_str = Util.endecode_string(matched.group(), encode_pair_forall[0],encode_pair_forall[1])
body_str = matched.group('body')
#print "body", body_str
normal_str = __normalize_fluents(body_str)
#print "normal", normal_str
add_formula = __get_formula_from_local_dict()
#--(***)---return matched.group('head')+ '{'+ add_formula+' and '+normal_str+ '}' if add_formula!="" else encoded_str
#print matched.group()
#exit(0)
return "%s{ %s&(%s)} }"% (matched.group('head'), add_formula, normal_str) if add_formula!="" else encoded_str
def __get_ispl_update(fluent_tuple_list, p1_action_tuple_list, p2_action_tuple_list, model):
universe, assignment, default_value = model
ispl_fluent_list = ['%s%s'%(f,'_'.join(para_list)) for f, para_list, sort in fluent_tuple_list]
fluent_list = ['%s(%s)'%(f,','.join(para_list)) for f, para_list, sort in fluent_tuple_list]
predicates = context_operator.get_predicates()
fun_fluent_list = [('%s(%s)'%(f,','.join(para_list)), sort) for f, para_list, sort in fluent_tuple_list if f not in predicates]
pred_fluent_list = ['%s(%s)'%(f,','.join(para_list)) for f, para_list, sort in fluent_tuple_list if f in predicates and f!='turn']
#print fun_fluent_list
#print pred_fluent_list
fluent_value_list = sum([list(itertools.product([fluent],universe[sort])) \
for fluent, sort in fun_fluent_list] ,[])
fluent_value_list = ['%s=%s'%(fluent,value) for fluent, value in fluent_value_list]
fluent_value_list.extend(pred_fluent_list)
ispl_p1_action_list = ['Player1.Action = %s%s'%(a,'_'.join(para_list)) for a, para_list in p1_action_tuple_list]
p1_action_list = ['%s(%s)'%(a,','.join(para_list)) for a, para_list in p1_action_tuple_list]
ispl_p2_action_list = ['Player2.Action = %s%s'%(a,'_'.join(para_list)) for a, para_list in p2_action_tuple_list]
p2_action_list = ['%s(%s)'%(a,','.join(para_list)) for a, para_list in p2_action_tuple_list]
action_pair_list = [(a,b) for a, b in zip(p1_action_list+p2_action_list, ispl_p1_action_list+ispl_p2_action_list)]
update_pair_list = [ (a,b,c) for a, (b,c) in itertools.product(fluent_value_list, action_pair_list)]
update_pair_list = [ (fluent, atomic_regress.poss_or_ssa(action, fluent), ispl_action) \
for fluent, action, ispl_action in update_pair_list]
# transform (=>) to (not or)
update_pair_list = [ (a, Formula.transform_entailment(b), c) for a, b, c in update_pair_list]
update_pair_list = [ (a, Formula.grounding(b,model), c) for a, b, c in update_pair_list]
update_pair_list = [ (a, ____ispl_simplify(b,'Player1.Action'), c) for a, b, c in update_pair_list]
#update_pair_list = [ (a, b, c) for a, b, c in update_pair_list if b is not None]
pred_fluent_list = ['%s(%s)'%(f,','.join(para_list)) for f, para_list, sort in fluent_tuple_list if f in predicates]
# add =true to each predicates
update_pair_list = [ (fluent, ____to_ispl_preds(update, pred_fluent_list), ispl_action) for fluent, update, ispl_action in update_pair_list]
fun_update_pair_list = [ (fluent, update, ispl_action) for fluent, update, ispl_action in update_pair_list if fluent not in pred_fluent_list and update !='false']
pred_update_pair_list = [ (fluent, update, ispl_action) for fluent, update, ispl_action in update_pair_list if fluent in pred_fluent_list]
update_list = ['%s if (%s) and %s;'%(fluent, update, ispl_action) for fluent, update, ispl_action in fun_update_pair_list ]
update_list += ['%s=true if (%s) and %s;'%(fluent, update, ispl_action) for fluent, update, ispl_action in pred_update_pair_list if update !='false' ]
update_list += ['%s=false if !(%s) and %s;'%(fluent, update, ispl_action) for fluent, update, ispl_action in pred_update_pair_list if update !='false' ]
update_list += ['%s=false if %s;'%(fluent, ispl_action) for fluent, update, ispl_action in pred_update_pair_list if update =='false' ]
update_list += turn_list
#update_list = [____add_env(formula, fluent_list) for formula in update_list]
update_list = [ Util.endecode_string(formula, fluent_list, ispl_fluent_list) for formula in update_list]
update_list = [ ____to_ispl_logic(formula) for formula in update_list]
#return '\n '.join(update_list)
return update_list
def __grounding_conjunct(var_list,
sorts,
formula,
universe,
var_constraint_dict=None):
#vars_consts = [ (var, var_constraint_dict[var]) if var in var_constraint_dict else (var, universe[sorts[e]]) for e, var in enumerate(var_list) ]
#print '~~~~', var_list, sorts, formula, universe
vars_consts = [(var, universe[sorts[e]]) for e, var in enumerate(var_list)]
#print vars_consts
consts_list = list(itertools.product(*zip(*vars_consts)[1]))
#print consts_list
instances = [
Util.endecode_string(formula, var_list, list(consts))
for consts in consts_list
]
return '|'.join(instances)
def __normalize_fluents(encoded_str): encoded_str = " "+encoded_str+" " # in order to detect fun_pre and fun_pos (sometimes fails) new_encoded_str = encoded_str while True: if context_operator.get_nregx_function_patterns() ==list(): break #for nreg_fluent_pattern in nreg_fluent_pattern_list: for nreg_fluent_pattern in context_operator.get_nregx_function_patterns(): new_encoded_str = Util.repeat_replace_inner_with_pattern(nreg_fluent_pattern, __mrepl_detect_fluent, encoded_str) encoded_str = new_encoded_str #print '---',encoded_str if new_encoded_str == encoded_str: new_encoded_str = re.sub(pattern.inner_parenth, __mrepl_encode, encoded_str) #print "replace () -> []", new_encoded_str if encoded_str == new_encoded_str: break encoded_str = new_encoded_str return Util.endecode_string(encoded_str, encode_pair[1], encode_pair[0]).strip()
def ____add_env(formula, fluent_list): new_fleunt_list = ['Environment.%s'%(fluent) for fluent in fluent_list] return Util.endecode_string(formula, fluent_list, new_fleunt_list)
def ____to_ispl_preds(formula, pred_list): new_pred_list = ['%s=true'%(pred) for pred in pred_list] return Util.endecode_string(formula, pred_list, new_pred_list)
def ____to_ispl_logic(formula): #print zip(encode_ispl[0], encode_ispl[1]) #return Util.repeat_do_function(Util.sub_lambda_exp, zip(encode_ispl[0], encode_ispl[1]), formula) #return Util.repeat_do_function(Util.sub_lambda_exp, zip(encode_ispl[0], encode_ispl[1]), formula) return Util.endecode_string(formula, encode_ispl[0], encode_ispl[1])
def ____to_ispl_vars(formula, fluent_list, ispl_fluent_list): return Util.endecode_string(formula, fluent_list, ispl_fluent_list)
def __mrepl_entailment_quantifier(matched):
#print matched.groups()
formula = __eliminate_bracket(matched.group(3))
return Util.endecode_string(
"%s(%s)[%s]" % (matched.group(1), matched.group(2), formula),
encode_pair[0], encode_pair[1])
def __mrepl_encode(matched): match_str=matched.group() encoded_str=Util.endecode_string(match_str, encode_pair[0], encode_pair[1]) return encoded_str
