def check_node(self, n):
x = var_to_skolem('__', Variable('X', n.sort)).suffix(str(n.sort))
y = var_to_skolem('__', Variable('Y', n.sort)).suffix(str(n.sort))
# print "x.sort: {}",format(x.sort)
self.solver.push()
s = self.solver
# if we have a witness we can show node is definite (present in all models)
wit = get_witness(n)
# print "checking: {}".format(n.fmla)
cube = substitute_clause(n.fmla, {'X': x})
# print "cube: {!r}".format(cube)
# print wit
# if wit != None:
## print "wit: {}, wit.sort: {}, x.sort: {}".format(wit,wit.sort,x.sort)
res = s_check_cube(s, cube,
(Atom(equals, [x, wit]) if wit != None else None))
## print"check cube: %s = %s" % (cube,res)
# res = s_check_cube(s,substitute_clause(n.fmla,{'X':x}))
# print "status: {}".format(res)
n.status = res
s_add(s, cube_to_z3(substitute_clause(n.fmla, {'X': x})))
s_add(s, cube_to_z3(substitute_clause(n.fmla, {'X': y})))
s_add(s, cube_to_z3([Literal(0, Atom(equals, [x, y]))]))
n.summary = s.check() != z3.unsat
self.solver.pop()
def check_edge(self,f1,f2,solver):
x = var_to_skolem('__',Variable('X',self.sorts[0])).suffix(str(self.sorts[0]))
y = var_to_skolem('__',Variable('Y',self.sorts[1])).suffix(str(self.sorts[1]))
solver.push()
s_add(solver,cube_to_z3(substitute_clause(f1,{'X':x})))
s_add(solver,cube_to_z3(substitute_clause(f2,{'X':y})))
# print "xsort: {}, ysort: {}".format(x.get_sort(),y.get_sort())
# print "rel_lit: {}, subs: {}".format(self.rel_lit,substitute_lit(self.rel_lit,{'X':x,'Y':y}))
res = s_check_cube(solver,[substitute_lit(self.rel_lit,{'X':x,'Y':y})])
solver.pop()
return res
def get_facts(self, rels, definite=True):
clauses = []
if not definite:
clauses += [[~lit for lit in n.fmla] for n in self.all_nodes
if n.status == "false"]
clauses += [
rela_fact(1, equals, n, n) for n in self.all_nodes
if (n.status != "false" and not n.summary and not any(
is_equality_lit(lit) for lit in n.fmla))
]
for n in self.all_nodes:
if n.status == 'true':
wit = get_witness(n)
if wit != None:
fmla = substitute_clause(n.fmla, {'X': (wit)})
clauses += [[lit] for lit in fmla
if not is_taut_equality_lit(lit)]
names = set(
n.name for n in self.all_nodes
if (n.status == "true" if definite else n.status != "false"))
for (r, tvals) in rels:
if tvals:
clauses += r.get_definite_facts(
names, tvals) if definite else r.get_facts(names, tvals)
return clauses
def check_edge(self, f1, f2, solver):
x = var_to_skolem('__',
Variable('X',
self.sorts[0])).suffix(str(self.sorts[0]))
y = var_to_skolem('__',
Variable('Y',
self.sorts[1])).suffix(str(self.sorts[1]))
solver.push()
s_add(solver, cube_to_z3(substitute_clause(f1, {'X': x})))
s_add(solver, cube_to_z3(substitute_clause(f2, {'X': y})))
# print "xsort: {}, ysort: {}".format(x.get_sort(),y.get_sort())
# print "rel_lit: {}, subs: {}".format(self.rel_lit,substitute_lit(self.rel_lit,{'X':x,'Y':y}))
res = s_check_cube(solver,
[substitute_lit(self.rel_lit, {
'X': x,
'Y': y
})])
solver.pop()
return res
def rela_fact(polarity, relname, n1, n2):
return ([~lit for lit in fmla1] + [
~lit
for lit in substitute_clause(n2.fmla, {'X': Variable('Y', n2.sort)})
] + [
Literal(
polarity,
Atom(relname, [Variable('X', n1.sort),
Variable('Y', n2.sort)]))
])
def enumerate(self, memo,test):
atom = self.lit.atom
if self.lit.polarity == 1 and is_atom(atom) and atom.relname in memo:
params,value = memo[atom.relname]
assert len(params) == len(atom.args)
subst = dict(zip(params,atom.args))
res = [substitute_clause(cl,subst) for cl in value]
# print "blif: {} {} {} {}".format(atom,params,value,res)
return res
return [[self.lit]] if test([self.lit]) else []
def eval(self, memo, relalg):
atom = self.lit.atom
if self.lit.polarity == 1 and atom.relname in memo:
params,value = memo[atom.relname]
if len(params) != len(atom.args):
print "{} {} {}".format(self,params,value)
assert len(params) == len(atom.args)
subst = dict(zip(params,atom.args))
return [(substitute_clause(cl,subst),relalg.subst(r,subst)) for (cl,r) in value]
v = relalg.prim(self.lit)
return [([self.lit],v)] if not relalg.empty(v) else []
def check_node(self,n):
x = var_to_skolem('__',Variable('X',n.sort)).suffix(str(n.sort))
y = var_to_skolem('__',Variable('Y',n.sort)).suffix(str(n.sort))
# print "x.sort: {}",format(x.sort)
self.solver.push()
s = self.solver
# if we have a witness we can show node is definite (present in all models)
wit = get_witness(n)
# print "checking: {}".format(n.fmla)
cube = substitute_clause(n.fmla,{'X':x})
# print "cube: {!r}".format(cube)
# print wit
# if wit != None:
## print "wit: {}, wit.sort: {}, x.sort: {}".format(wit,wit.sort,x.sort)
res = s_check_cube(s,cube,(Atom(equals,[x,wit]) if wit != None else None))
## print"check cube: %s = %s" % (cube,res)
# res = s_check_cube(s,substitute_clause(n.fmla,{'X':x}))
# print "status: {}".format(res)
n.status = res
s_add(s,cube_to_z3(substitute_clause(n.fmla,{'X':x})))
s_add(s,cube_to_z3(substitute_clause(n.fmla,{'X':y})))
s_add(s,cube_to_z3([Literal(0,Atom(equals,[x,y]))]))
n.summary = s.check() != z3.unsat
self.solver.pop()
def check_edge(self,f1,solver):
x = var_to_skolem('__',Variable('X',self.sorts[0])).suffix(str(self.sorts[0]))
solver.push()
s_add(solver,cube_to_z3(substitute_clause(f1,{'X':x})))
# print "xsort: {}, ysort: {}".format(x.get_sort(),y.get_sort())
# print "rel_lit: {}, subs: {}".format(self.rel_lit,substitute_lit(self.rel_lit,{'X':x,'Y':y}))
f = self.fmla
vals = [Constant(Symbol(y,f.sort.rng)) for y in f.sort.rng.defines()]
status = 'undef'
for v in vals:
if s_check_fmla(solver,self.test_lit(x,v).atom) == z3.unsat:
status = v
break
solver.pop()
return status
def check_edge(self, f1, solver):
x = var_to_skolem('__',
Variable('X',
self.sorts[0])).suffix(str(self.sorts[0]))
solver.push()
s_add(solver, cube_to_z3(substitute_clause(f1, {'X': x})))
# print "xsort: {}, ysort: {}".format(x.get_sort(),y.get_sort())
# print "rel_lit: {}, subs: {}".format(self.rel_lit,substitute_lit(self.rel_lit,{'X':x,'Y':y}))
f = self.fmla
vals = [Constant(Symbol(y, f.sort.rng)) for y in f.sort.rng.defines()]
status = 'undef'
for v in vals:
if s_check_fmla(solver, self.test_lit(x, v).atom) == z3.unsat:
status = v
break
solver.pop()
return status
def get_facts(self,rels,definite=True):
clauses = []
if not definite:
clauses += [[~lit for lit in n.fmla] for n in self.all_nodes if n.status == "false"]
clauses += [rela_fact(1,equals,n,n)
for n in self.all_nodes
if (n.status != "false" and not n.summary and not any(is_equality_lit(lit) for lit in n.fmla))]
for n in self.all_nodes:
if n.status == 'true':
wit = get_witness(n)
if wit != None:
fmla = substitute_clause(n.fmla,{'X':(wit)})
clauses += [[lit] for lit in fmla if not is_taut_equality_lit(lit)]
names = set(n.name for n in self.all_nodes if (n.status == "true" if definite else n.status != "false"))
for (r,tvals) in rels:
if tvals:
clauses += r.get_definite_facts(names,tvals) if definite else r.get_facts(names,tvals)
return clauses
def add_witness_constraint(self,node,nc):
g = self
fmla = substitute_clause(node.fmla,{'X':nc})
self.add_constraints([[lit]
for lit in fmla if not is_taut_equality_lit(lit)],False)
def rela_fact(polarity,relname,n1,n2):
return ([~lit for lit in fmla1]
+ [~lit for lit in substitute_clause(n2.fmla,{'X':Variable('Y',n2.sort)})]
+ [Literal(polarity,Atom(relname,[Variable('X',n1.sort),Variable('Y',n2.sort)]))])
def add_witness_constraint(self, node, nc):
g = self
fmla = substitute_clause(node.fmla, {'X': nc})
self.add_constraints(
[[lit] for lit in fmla if not is_taut_equality_lit(lit)], False)
