def model_facts(h, ignore, clauses1, upclose=False):
# define the universe for each sort:
uc = [
fact for s in h.sorts()
for fact in model_universe_facts(h, s, upclose)
]
# values of constants in formula
temp = [[(ivy_logic.Constant(c),
get_model_constant(h.model, ivy_logic.Constant(c)))]
for c in used_constants_clauses(clauses1)
if not ignore(c) and c not in ivy_logic.sig.constructors]
# print "temp = {}".format(temp)
vc = [[
ivy_logic._eq_lit(ivy_logic.Constant(c),
get_model_constant(h.model, ivy_logic.Constant(c)))
] for c in used_constants_clauses(clauses1)
if not ignore(c) and c not in ivy_logic.sig.constructors]
# print "model_facts vc = {}".format(vc)
# values of relations in formula
# print "used_relations_clauses = {}".format(used_relations_clauses(clauses1))
vr = [[l] for (r, n) in used_relations_clauses(clauses1).iteritems()
if not ignore(r) for l in relation_model_to_clauses(h, r, n)]
# values of functions in formula
fns = set(f for (f, arity) in functions_clauses(clauses1)
if not ignore(f) and arity >= 1)
vf = [[l] for f in fns for l in function_model_to_clauses(h, f)]
res = uc + vc + vr + vf
return Clauses(res)
def clauses_model_to_clauses(clauses1,
ignore=None,
implied=None,
model=None,
numerals=False):
""" Return a model of clauses1 or None. Model is represented by a
clause set that uniquely characterizes it. The function "ignore", if
provided, returns true for symbols that should be ignored in the
model (tyipically skolems).
"""
## print "clauses_model_to_clauses clauses1 = {}".format(clauses1)
h = model_if_none(clauses1, implied, model)
ignore = ignore if ignore != None else lambda x: False
res = model_facts(h, ignore, clauses1)
# if using numerals, replace the universe elements with them
if numerals:
m = dict((c.rep, ivy_logic.Constant(c.rep.rename(lambda s: str(i))))
for s in h.sorts()
for i, c in enumerate(h.sorted_sort_universe(s)))
# else, existentially quantify the names of the universe elements
else:
m = dict((c.rep, ivy_logic.Constant(c.rep.prefix('__')))
for s in h.sorts() for c in h.sort_universe(s))
res = substitute_constants_clauses(res, m)
# print "clauses_model_to_clauses res = {}".format(res)
return res
def get_model_constant(m,t):
s = t.get_sort()
if isinstance(s,ivy_logic.EnumeratedSort) and not use_z3_enums:
for v in s.defines():
w = ivy_logic.Constant(ivy_logic.Symbol(v,s))
if z3.is_true(m.eval(encode_equality(t,w))):
return w
# print "model: {}".format(m.sexpr())
# print "term: {}".format(t)
res = ivy_logic.Constant(ivy_logic.Symbol(s.defines()[0],s))
print "warning: model doesn't give a value for enumerated term {}. returning {}.".format(t,res)
return res
# assert False # model doesn't give a value for enumerated term
return constant_from_z3(s,m.eval(term_to_z3(t),model_completion=True))
def numeral_assign(clauses,h):
num_by_sort = defaultdict(list)
numerals = [c for c in used_constants_clauses(clauses) if c.is_numeral()]
for num in numerals:
num_by_sort[num.sort].append(num)
# print "num_by_sort: {}".format(numerals)
foom = dict()
used = set()
# print "starting: foom = {}".format(foom)
for s in h.sorts():
# print "na sort: {}".format(repr(s))
if ivy_logic.is_interpreted_sort(s):
continue
# print "sort loop: sort = {}, foom = {}".format(s,foom)
for num in num_by_sort[s]:
# print "foom = {}".format(foom)
numv = h.eval_constant(num)
# print "eval: {}:{} = {}".format(num,num.sort,numv)
if numv in foom:
print "two numerals assigned same value!: {} = {}".format(num,foom[numv])
else:
# print "assigning {} to {}".format(num,numv)
foom[numv] = num
used.add(num)
i = 0
for c in h.sorted_sort_universe(s):
if c not in foom:
while True:
num = ivy_logic.Constant(c.rep.rename(lambda s:str(i)))
i = i + 1
if num not in used:
foom[c.rep] = num
break
return foom
def function_model_to_clauses(h,f):
sort = f.sort
rng = sort.rng
res = []
fterm = fun_inst(f)
if isinstance(rng,ivy_logic.EnumeratedSort) and not use_z3_enums:
for c in rng.defines():
eq = ivy_logic._eq_lit(fterm,ivy_logic.Constant(ivy_logic.Symbol(c,rng)))
# print "function_model_to_clauses: {}".format(eq)
get_lit_facts(h,eq,res)
# non-enumerated function types
else:
lit = ivy_logic.Literal(1,fun_eq_inst(f))
get_lit_facts(h,lit,res)
# print "fun facts: {}".format([str(r) for r in res])
return res
def clauses_model_to_diagram(clauses1,
ignore=None,
implied=None,
model=None,
axioms=None,
weaken=True):
""" Return a diagram of a model of clauses1 or None. The function "ignore", if
provided, returns true for symbols that should be ignored in the
diagram.
"""
print "clauses_model_to_diagram clauses1 = {}".format(clauses1)
if axioms == None:
axioms = true_clauses
h = model_if_none(and_clauses(clauses1, axioms), implied, model)
ignore = ignore if ignore != None else lambda x: False
res = model_facts(h, (lambda x: False), clauses1,
upclose=True) # why not pass axioms?
print "clauses_model_to_diagram res = {}".format(res)
# find representative elements
# find representatives of universe elements
reps = dict()
for c in used_constants_clauses(clauses1):
# print "constant: {}".format(c)
mc = get_model_constant(h.model, ivy_logic.Constant(c))
# print "value: {}".format(mc)
if mc.rep not in reps or reps[
mc.rep].rep.is_skolem() and not c.is_skolem():
reps[mc.rep] = ivy_logic.Constant(c)
for s in h.sorts():
for e in h.sort_universe(s):
if e.rep not in reps:
reps[e.rep] = e.rep.skolem()()
print "clauses_model_to_diagram reps = {}".format(reps)
# filter out clauses using universe elements without reps
# res = [cls for cls in res if all(c in reps for c in used_constants_clause(cls))]
# replace universe elements with their reps
print "clauses_model_to_diagram res = {}".format(res)
res = substitute_constants_clauses(res, reps)
# filter defined skolems
# this caused a bug in the leader example. the generated diagram did not satisfy clauses1
res.fmlas = [
f for f in res.fmlas
if not any((x.is_skolem() and x in clauses1.defidx)
for x in used_symbols_ast(f))
]
print "clauses_model_to_diagram res = {}".format(res)
uc = Clauses([[
ivy_logic._eq_lit(ivy_logic.Variable('X', c.get_sort()), reps[c.rep])
for c in h.sort_universe(s)
] for s in h.sorts()])
print "clauses_model_to_diagram uc = {}".format(uc)
# uc = true_clauses()
if weaken:
res = unsat_core(res, and_clauses(uc, axioms),
clauses1) # implied not used here
print "clauses_model_to_diagram res = {}".format(res)
# print "foo = {}".format(unsat_core(and_clauses(uc,axioms),true_clauses(),clauses1))
# filter out non-rep skolems
repset = set(c.rep for e, c in reps.iteritems())
print "clauses_model_to_diagram repset = {}".format(repset)
ign = lambda x, ignore=ignore: (ignore(x) and not x in repset)
res = Clauses([
cl for cl in res.fmlas
if not any(ign(c) for c in used_symbols_ast(cl))
])
print "clauses_model_to_diagram res = {}".format(res)
return res
def constant_from_z3(c):
return ivy_logic.Constant(ivy_logic.Symbol(repr(c),
sort_from_z3(c.sort())))
def constant_from_z3(sort, c):
if z3.is_true(c):
return ivy_logic.And()
if z3.is_false(c):
return ivy_logic.Or()
return ivy_logic.Constant(ivy_logic.Symbol(repr(c), sort))
