def sort_infer(term):
res = concretize_sorts(term)
for x in chain(lu.used_variables(res),lu.used_constants(res)):
if lg.contains_topsort(x.sort) or lg.is_polymorphic(x.sort):
raise IvyError(None,"cannot infer sort of {} in {}".format(x,term))
# print "sort_infer: res = {!r}".format(res)
return res
def sort_infer(term):
res = concretize_sorts(term)
for x in chain(lu.used_variables(res),lu.used_constants(res)):
if lg.contains_topsort(x.sort) or lg.is_polymorphic(x.sort):
raise IvyError(None,"cannot infer sort of {}".format(x))
# print "sort_infer: res = {!r}".format(res)
return res
def check_concretely_sorted(term,no_error=False,unsorted_var_names=()):
for x in chain(lu.used_variables(term),lu.used_constants(term)):
if lg.contains_topsort(x.sort) or lg.is_polymorphic(x.sort):
if x.name not in unsorted_var_names:
if no_error:
raise lg.SortError
raise IvyError(None,"cannot infer sort of {} in {}".format(x,repr(term)))
def check_concretely_sorted(term, no_error=False, unsorted_var_names=()):
for x in chain(lu.used_variables(term), lu.used_constants(term)):
if lg.contains_topsort(x.sort) or lg.is_polymorphic(x.sort):
if x.name not in unsorted_var_names:
if no_error:
raise lg.SortError
raise IvyError(
None,
"cannot infer sort of {} in {}".format(x, repr(term)))
def is_concretely_sorted(term):
return not lg.contains_topsort(term) and not lg.is_polymorphic(term)
def is_concretely_sorted(term):
return not lg.contains_topsort(term) and not lg.is_polymorphic(term)
def infer_sorts(t, env=None):
"""
Infer the sort of term t in environment env.
env maps symbol names to sort variables.
The result is a pair: (s, tt) where s is a sort or sort variable
with the sort of t in env, and tt is a closure that, when called,
will concretize t according to inferred sort information at its
call time.
If env is not None, it must contain all the free variables and
constants used in t.
"""
if env is None:
names = free_variables(t,
by_name=True).union(x.name
for x in used_constants(t))
env = dict((name, SortVar()) for name in names)
if type(t) in (Var, Const):
if is_polymorphic(t): # each instance can have different sort
s = insert_sortvars(t.sort, {})
else:
s = env[t.name]
unify(s, t.sort)
return s, lambda: type(t)(t.name, convert_from_sortvars(s))
elif type(t) is Apply:
func_s, func_t = infer_sorts(t.func, env)
xys = [infer_sorts(tt, env) for tt in t.terms]
terms_s = [x for x, y in xys]
terms_t = [y for x, y in xys]
sorts = terms_s + [SortVar()]
unify(func_s, FunctionSort(*sorts))
return sorts[-1], lambda: Apply(func_t(), *(x() for x in terms_t))
elif type(t) is Eq:
s1, t1 = infer_sorts(t.t1, env)
s2, t2 = infer_sorts(t.t2, env)
unify(s1, s2)
return Boolean, lambda: Eq(t1(), t2())
elif type(t) is Ite:
s_cond, t_cond = infer_sorts(t.cond, env)
s_then, t_then = infer_sorts(t.t_then, env)
s_else, t_else = infer_sorts(t.t_else, env)
unify(s_cond, Boolean)
unify(s_then, s_else)
return s_then, lambda: Ite(t_cond(), t_then(), t_else())
elif type(t) in (Not, And, Or, Implies, Iff):
xys = [infer_sorts(tt, env) for tt in t]
terms_s = [x for x, y in xys]
terms_t = [y for x, y in xys]
for s in terms_s:
unify(s, Boolean)
return Boolean, lambda: type(t)(*[x() for x in terms_t])
elif type(t) in (ForAll, Exists):
# create a copy of the environment and shadow that quantified
# variables
env = env.copy()
env.update((v.name, SortVar()) for v in t.variables)
vars_t = [infer_sorts(v, env)[1] for v in t.variables]
body_s, body_t = infer_sorts(t.body, env)
unify(body_s, Boolean)
return Boolean, lambda: type(t)(
[x() for x in vars_t],
body_t(),
)
elif hasattr(t, 'clone'):
xys = [infer_sorts(tt, env) for tt in t.args]
terms_t = [y for x, y in xys]
return TopSort(), lambda: t.clone([x() for x in terms_t])
else:
assert False, type(t)
def infer_sorts(t, env=None):
"""
Infer the sort of term t in environment env.
env maps symbol names to sort variables.
The result is a pair: (s, tt) where s is a sort or sort variable
with the sort of t in env, and tt is a closure that, when called,
will concretize t according to inferred sort information at its
call time.
If env is not None, it must contain all the free variables and
constants used in t.
"""
if env is None:
names = free_variables(t, by_name=True).union(
x.name for x in used_constants(t)
)
env = dict((name, SortVar()) for name in names)
if type(t) in (Var, Const):
if is_polymorphic(t): # each instance can have different sort
s = insert_sortvars(t.sort,{})
else:
s = env[t.name]
unify(s, t.sort)
return s, lambda: type(t)(t.name, convert_from_sortvars(s))
elif type(t) is Apply:
func_s, func_t = infer_sorts(t.func, env)
xys = [infer_sorts(tt, env) for tt in t.terms]
terms_s = [x for x, y in xys]
terms_t = [y for x, y in xys]
sorts = terms_s + [SortVar()]
unify(func_s, FunctionSort(*sorts))
return sorts[-1], lambda: Apply(func_t(), *(
x() for x in terms_t
))
elif type(t) is Eq:
s1, t1 = infer_sorts(t.t1, env)
s2, t2 = infer_sorts(t.t2, env)
unify(s1, s2)
return Boolean, lambda: Eq(t1(), t2())
elif type(t) is Ite:
s_cond, t_cond = infer_sorts(t.cond, env)
s_then, t_then = infer_sorts(t.t_then, env)
s_else, t_else = infer_sorts(t.t_else, env)
unify(s_cond, Boolean)
unify(s_then, s_else)
return s_then, lambda: Ite(t_cond(), t_then(), t_else())
elif type(t) in (Not, And, Or, Implies, Iff):
xys = [infer_sorts(tt, env) for tt in t]
terms_s = [x for x, y in xys]
terms_t = [y for x, y in xys]
for s in terms_s:
unify(s, Boolean)
return Boolean, lambda: type(t)(*[
x() for x in terms_t
])
elif type(t) in (ForAll, Exists):
# create a copy of the environment and shadow that quantified
# variables
env = env.copy()
env.update((v.name, SortVar()) for v in t.variables)
vars_t = [infer_sorts(v, env)[1] for v in t.variables]
body_s, body_t = infer_sorts(t.body, env)
unify(body_s, Boolean)
return Boolean, lambda: type(t)(
[x() for x in vars_t],
body_t(),
)
elif hasattr(t,'clone'):
xys = [infer_sorts(tt, env) for tt in t.args]
terms_t = [y for x, y in xys]
return TopSort(), lambda: t.clone([
x() for x in terms_t
])
else:
assert False, type(t)
