def subactions(self) :
if isinstance(self.args[0],ivy_ast.Some):
ps = list(self.args[0].params())
fmla = self.args[0].fmla()
vs = [Variable('V{}'.format(idx),x.sort) for idx,x in enumerate(ps)]
subst = dict((c,v) for c,v in zip(ps,vs))
sfmla = substitute_constants_ast(fmla,subst)
if isinstance(self.args[0],ivy_ast.SomeMinMax):
idx = self.args[0].index()
if idx not in ps:
ltsym = Symbol('<',RelationSort([idx.sort,idx.sort]))
operator = lambda x,y: Not(ltsym(x,y))
ivar = substitute_constants_ast(idx,subst)
comp = operator(ivar,idx) if isinstance(self.args[0],ivy_ast.SomeMin) else operator(idx,ivar)
fmla = And(fmla,Implies(sfmla,comp))
else :
leqsym = Symbol('<=',RelationSort([idx.sort,idx.sort]))
operator = lambda x,y: And(leqsym(x,y),Not(Equals(x,y)))
ivar = next(v for p,v in zip(ps,vs) if p == idx)
comp = operator(ivar,idx) if isinstance(self.args[0],ivy_ast.SomeMin) else operator(idx,ivar)
fmla = And(fmla,Not(And(sfmla,comp)))
if_part = LocalAction(*(ps+[Sequence(AssumeAction(fmla),self.args[1])]))
else_action = self.args[2] if len(self.args) >= 3 else Sequence()
else_part = Sequence(AssumeAction(Not(sfmla)),else_action)
# iu.dbg('if_part')
# iu.dbg('else_part')
else:
if not is_boolean(self.args[0]):
raise IvyError(self,'condition must be boolean')
if_part = Sequence(AssumeAction(self.args[0]),self.args[1])
else_action = self.args[2] if len(self.args) >= 3 else Sequence()
else_part = Sequence(AssumeAction(dual_formula(self.args[0])),else_action)
return if_part,else_part
def make_skolems(fmla, ast, pol, univs):
global macro_dep_map
global strat_map
if isinstance(fmla, il.Not):
make_skolems(fmla.args[0], ast, not pol, univs)
if isinstance(fmla, il.Implies):
make_skolems(fmla.args[0], ast, not pol, univs)
make_skolems(fmla.args[1], ast, pol, univs)
is_e = il.is_exists(fmla)
is_a = il.is_forall(fmla)
if is_e and pol or is_a and not pol:
fvs = set(il.free_variables(fmla))
for u in univs:
if u in fvs:
for e in il.quantifier_vars(fmla):
macro_dep_map[e].add(strat_map[u])
if is_e and not pol or is_a and pol:
make_skolems(fmla.args[0], ast, pol,
univs + list(il.quantifier_vars(fmla)))
for arg in fmla.args:
make_skolems(arg, ast, pol, univs)
if isinstance(fmla, il.Ite):
make_skolems(fmla.args[0], ast, not pol, univs)
if isinstance(fmla, il.Iff) or (il.is_eq(fmla)
and il.is_boolean(fmla.args[0])):
make_skolems(fmla.args[0], ast, not pol, univs)
make_skolems(fmla.args[1], ast, not pol, univs)
def get_qa_arcs(fmla,ast,pol,univs,strat_map):
if isinstance(fmla,il.Not):
for a in get_qa_arcs(fmla.args[0],ast,not pol,univs,strat_map):
yield a
return
if isinstance(fmla,il.Implies):
for a in get_qa_arcs(fmla.args[0],ast,not pol,univs,strat_map):
yield a
for a in get_qa_arcs(fmla.args[1],ast,pol,univs,strat_map):
yield a
return
is_e = il.is_exists(fmla)
is_a = il.is_forall(fmla)
if is_e and pol or is_a and not pol:
fvs = set(il.free_variables(fmla))
for u in univs:
if u in fvs:
for e in il.quantifier_vars(fmla):
yield (find(strat_map[u]),find(strat_map[e]),ast)
if is_e and not pol or is_a and pol:
for a in get_qa_arcs(fmla.args[0],ast,pol,univs+list(il.quantifier_vars(fmla)),strat_map):
yield a
for arg in fmla.args:
for a in get_qa_arcs(arg,ast,pol,univs,strat_map):
yield a
if isinstance(fmla,il.Ite):
for a in get_qa_arcs(fmla.args[0],ast,not pol,univs,strat_map):
yield a
if isinstance(fmla,il.Iff) or (il.is_eq(fmla) and il.is_boolean(fmla.args[0])):
for a in get_qa_arcs(fmla.args[0],ast,not pol,univs,strat_map):
yield a
for a in get_qa_arcs(fmla.args[1],ast,not pol,univs,strat_map):
yield a
def get_qa_arcs(fmla,ast,pol,univs,strat_map):
if isinstance(fmla,il.Not):
for a in get_qa_arcs(fmla.args[0],ast,not pol,univs,strat_map):
yield a
return
if isinstance(fmla,il.Implies):
for a in get_qa_arcs(fmla.args[0],ast,not pol,univs,strat_map):
yield a
for a in get_qa_arcs(fmla.args[1],ast,pol,univs,strat_map):
yield a
return
is_e = il.is_exists(fmla)
is_a = il.is_forall(fmla)
if is_e and pol or is_a and not pol:
fvs = set(il.free_variables(fmla))
for u in univs:
if u in fvs:
for e in il.quantifier_vars(fmla):
yield (find(strat_map[u]),find(strat_map[e]),ast)
if is_e and not pol or is_a and pol:
for a in get_qa_arcs(fmla.args[0],ast,pol,univs+list(il.quantifier_vars(fmla)),strat_map):
yield a
for arg in fmla.args:
for a in get_qa_arcs(arg,ast,pol,univs,strat_map):
yield a
if isinstance(fmla,il.Ite):
for a in get_qa_arcs(fmla.args[0],ast,not pol,univs,strat_map):
yield a
if isinstance(fmla,il.Iff) or (il.is_eq(fmla) and il.is_boolean(fmla.args[0])):
for a in get_qa_arcs(fmla.args[0],ast,not pol,univs,strat_map):
yield a
for a in get_qa_arcs(fmla.args[1],ast,not pol,univs,strat_map):
yield a
def term_to_z3(term):
if ivy_logic.is_boolean(term):
return formula_to_z3_int(term)
if not term.args:
if isinstance(term, ivy_logic.Variable):
sorted = hasattr(term, 'sort')
sksym = term.rep + ':' + str(term.sort) if sorted else term.rep
res = z3_constants.get(sksym)
if res is not None: return res
# print str(term.sort)
sig = lookup_native(term.sort, sorts, "sort") if sorted else S
if sig == None:
sig = term.sort.to_z3()
# if sorted:
# print type(term.sort)
# print term.sort
# print type(sksym)
# print sksym
# print sig
res = z3.Const(sksym, sig)
z3_constants[sksym] = res
return res
res = z3_constants.get(term.rep)
if res is None:
# if isinstance(term.rep,str):
# print "{} : {}".format(term,term.rep)
if term.is_numeral():
res = numeral_to_z3(term.rep)
elif ivy_logic.is_enumerated(
term) and ivy_logic.is_interpreted_sort(term.sort):
res = enumerated_to_numeral(term)
else:
iso = term.rep.sort
# TODO: this is dangerous
sig = iso.to_z3() if iso is not None else S
# print "term: {}, iso : {}, sig = {}".format(term,iso,sig)
res = z3.Const(term.rep.name, sig)
z3_constants[term.rep] = res
elif isinstance(term, ivy_logic.Ite):
return z3.If(formula_to_z3_int(term.args[0]), term_to_z3(term.args[1]),
term_to_z3(term.args[2]))
else:
if not hasattr(term, 'rep'):
print term
print term.lineno
fun = z3_functions.get(term.rep)
if fun is None:
fun = lookup_native(term.rep, functions, "function")
if fun is None:
sig = term.rep.sort.to_z3()
fun = z3.Function(term.rep.name, *sig)
z3_functions[term.rep] = fun
args = [term_to_z3(arg) for arg in term.args]
res = apply_z3_func(fun, args)
return res
def term_to_z3(term):
if ivy_logic.is_boolean(term):
return formula_to_z3_int(term)
if not term.args:
if isinstance(term, ivy_logic.Variable):
sorted = hasattr(term, "sort")
sksym = term.rep + ":" + str(term.sort) if sorted else term.rep
res = z3_constants.get(sksym)
if res is not None:
return res
# print str(term.sort)
sig = lookup_native(term.sort, sorts, "sort") if sorted else S
if sig == None:
sig = term.sort.to_z3()
# if sorted:
# print type(term.sort)
# print term.sort
# print type(sksym)
# print sksym
# print sig
res = z3.Const(sksym, sig)
z3_constants[sksym] = res
return res
res = z3_constants.get(term.rep)
if res is None:
# if isinstance(term.rep,str):
# print "{} : {}".format(term,term.rep)
if term.is_numeral():
res = numeral_to_z3(term.rep)
elif ivy_logic.is_enumerated(term) and ivy_logic.is_interpreted_sort(term.sort):
res = enumerated_to_numeral(term)
else:
iso = term.rep.sort
# TODO: this is dangerous
sig = iso.to_z3() if iso != None else S
# print "term: {}, iso : {}, sig = {}".format(term,iso,sig)
res = z3.Const(term.rep.name, sig)
z3_constants[term.rep] = res
elif isinstance(term, ivy_logic.Ite):
return z3.If(formula_to_z3_int(term.args[0]), term_to_z3(term.args[1]), term_to_z3(term.args[2]))
else:
fun = z3_functions.get(term.rep)
if fun is None:
fun = lookup_native(term.rep, functions, "function")
if fun is None:
sig = term.rep.sort.to_z3()
fun = z3.Function(term.rep.name, *sig)
z3_functions[term.rep] = fun
args = [term_to_z3(arg) for arg in term.args]
res = apply_z3_func(fun, args)
return res
def int_update(self, domain, pvars):
# update = self.args[1].int_update(domain,pvars)
# return condition_update_on_fmla(update,self.args[0],domain.relations)
if not isinstance(self.args[0], ivy_ast.Some):
if not is_boolean(self.args[0]):
raise IvyError(self, 'condition must be boolean')
branches = [
self.args[1],
self.args[2] if len(self.args) >= 3 else Sequence()
]
upds = [a.int_update(domain, pvars) for a in branches]
return ite_action(self.args[0], upds[0], upds[1], domain.relations)
if_part, else_part = (a.int_update(domain, pvars)
for a in self.subactions())
return join_action(if_part, else_part, domain.relations)
