def check_covered(dim, set1, list_of_covers):
em = ExprManager()
s_cover = SmtEngine(em)
real_type = em.realType()
x = [em.mkVar("x_[%s]" % (j + 1), real_type) for j in range(dim)]
list_of_constraints = []
#x \in set1
list_of_constraints.append(get_point_membership_constraint(em, x, set1))
#x is not in any of the covers
for cover in list_of_covers:
list_of_constraints.append(
em.mkExpr(CVC4.NOT, get_point_membership_constraint(em, x, cover)))
s_cover.assertFormula(get_cvc4_and(em, list_of_constraints))
chk = s_cover.checkSat()
if (chk == 1):
return False
else:
return True
class CVCWrapper(object):
options = {
'produce-models': 'true',
# Enable experimental string support
'strings-exp': 'true',
# Enable modular arithmetic with constant modulus
'rewrite-divk': 'true',
'output-language': 'smt2',
'input-language': 'smt2'
}
logic = 'ALL_SUPPORTED'
def __init__(self, query_store=None):
self.asserts = None
self.query = None
self.em = None
self.solver = None
self.query_store = query_store
self.smtlib = None
def findCounterexample(self, asserts, query, timeout=None):
"""Tries to find a counterexample to the query while
asserts remains valid."""
startime = time.process_time()
self.em = ExprManager()
self.solver = SmtEngine(self.em)
if timeout is not None:
self.options['tlimit-per'] = timeout * 1000
for name, value in CVCWrapper.options.items():
self.solver.setOption(name, SExpr(str(value)))
self.solver.setLogic(CVCWrapper.logic)
self.query = query
self.asserts = asserts
result, model = self._findModel()
endtime = time.process_time()
log.debug("Timeout -- %s" % timeout)
log.debug("Result -- %s" % result)
log.debug("Model -- %s" % model)
log.debug("Solver time: {0:.2f} seconds".format(endtime - startime))
solvertime = endtime - startime
return result, model, solvertime
def _findModel(self):
self.solver.push()
exprbuilder = ExprBuilder(self.asserts, self.query, self.solver)
self.solver.assertFormula(exprbuilder.query.cvc_expr)
if self.query_store is not None:
self.smtlib = self._serialize(exprbuilder.query,
exprbuilder.cvc_vars)
self._savequery()
model = None
try:
result = self.solver.checkSat()
if not result.isSat():
ret = "UNSAT"
elif result.isUnknown():
ret = "UNKNOWN"
elif result.isSat():
ret = "SAT"
model = self._getModel(exprbuilder.cvc_vars)
else:
raise Exception("Unexpected SMT result")
except RuntimeError as r:
log.debug("CVC exception %s" % r)
ret = "UNKNOWN"
except TypeError as t:
log.error("CVC exception %s" % t)
ret = "UNKNOWN"
self.solver.pop()
return ret, model
def _savequery(self):
if not path.isdir(self.query_store):
raise IOError("Query folder {} not found".format(self.query_store))
smthash = sha224(bytes(str(self.query), 'UTF-8')).hexdigest()
filename = path.join(self.query_store, "{}.smt2".format(smthash))
log.debug('Writing query to {}'.format(filename))
with open(filename, 'w') as f:
f.write(self.smtlib)
@staticmethod
def _serialize(query, variables):
smtlib_template = Template("""
(set-logic $logic)
(set-option :strings-exp ${strings_exp})
(set-option :produce-models ${produce_models})
(set-option :rewrite-divk ${rewrite_divk})
$declarevars
(assert $query)
(check-sat)
$getvars
""")
assignments = {
name.replace('-', '_'): value
for name, value in CVCWrapper.options.items()
}
assignments['logic'] = CVCWrapper.logic
assignments['query'] = query
assignments['declarevars'] = "\n".join(
"(declare-fun {} () {})".format(name, var.CVC_TYPE)
for name, var in variables.items())
assignments['getvars'] = "\n".join("(get-value ({}))".format(name)
for name in variables)
return smtlib_template.substitute(assignments).strip()
@staticmethod
def _getModel(variables):
"""Retrieve the model generated for the path expression."""
return {
name: cvc_var.getvalue()
for (name, cvc_var) in variables.items()
}
class CVCWrapper(object):
options = {
'produce-models': 'true',
# Enable experimental string support
'strings-exp': 'true',
# Enable modular arithmetic with constant modulus
'rewrite-divk': 'true',
'output-language': 'smt2',
'input-language': 'smt2'
}
logic = 'ALL_SUPPORTED'
def __init__(self):
self.asserts = None
self.query = None
self.em = None
self.solver = None
self.smtlib = None
def findCounterexample(self, asserts, query, timeout=None):
"""Tries to find a counterexample to the query while
asserts remains valid."""
self.em = ExprManager()
self.solver = SmtEngine(self.em)
if timeout is not None:
self.options['tlimit-per'] = timeout * 1000
for name, value in CVCWrapper.options.items():
self.solver.setOption(name, SExpr(str(value)))
self.solver.setLogic(CVCWrapper.logic)
self.query = query
self.asserts = asserts
result, model = self._findModel()
return result, model
def _findModel(self):
self.solver.push()
exprbuilder = ExprBuilder(self.asserts, self.query, self.solver)
print("FORMULA: (assert " + exprbuilder.query.cvc_expr.toString() +
" )")
self.solver.assertFormula(exprbuilder.query.cvc_expr)
model = None
try:
result = self.solver.checkSat()
if not result.isSat():
ret = "UNSAT"
elif result.isUnknown():
ret = "UNKNOWN"
elif result.isSat():
ret = "SAT"
model = self._getModel(exprbuilder.cvc_vars)
else:
raise Exception("Unexpected SMT result")
except RuntimeError as r:
print("CVC exception %s" % r)
ret = "UNKNOWN"
except TypeError as t:
print("CVC exception %s" % t)
ret = "UNKNOWN"
self.solver.pop()
return ret, model
@staticmethod
def _getModel(variables):
"""Retrieve the model generated for the path expression."""
return {
name: cvc_var.getvalue()
for (name, cvc_var) in variables.items()
}
class Z3Str2Wrapper(object):
options = {
'produce-models': 'true',
# Enable experimental string support
'strings-exp': 'true',
# Enable modular arithmetic with constant modulus
'rewrite-divk': 'true',
# Per Query timeout of 30 seconds
'tlimit-per': 30000,
'output-language': 'smt2',
'input-language': 'smt2'
}
rename = {
'str.len': 'Length',
'str.contains': 'Contains',
'str.indexof': 'Indexof2',
'str.substr': 'Substring',
'str.++': 'Concat',
'str.replace': 'Replace',
'str.at': 'CharAt',
'bv2nat': 'bv2int'
}
logic = 'ALL_SUPPORTED'
def __init__(self, query_store=None):
if query_store is None:
self.query_store = mkdtemp()
else:
self.query_store = query_store
self.solvertime = 0
def findCounterexample(self, asserts, query, timeout=10**10):
starttime = time.process_time()
Z3Str2Wrapper.options['tlimit-per'] = timeout * 1000
self.solvetimeout = timeout
self.em = ExprManager()
self.solver = SmtEngine(self.em)
for name, value in Z3Str2Wrapper.options.items():
self.solver.setOption(name, SExpr(str(value)))
self.solver.setLogic(Z3Str2Wrapper.logic)
self.query = query
self.asserts = asserts
result, model = self._findModel()
endtime = time.process_time()
log.debug("Timeout -- %s" % timeout)
log.debug("Result -- %s" % result)
log.debug("Model -- %s" % model)
log.debug("Solver time: {0:.2f} seconds".format(timeout))
solvertime = endtime - starttime
return result, model, solvertime
def _findModel(self):
self.solver.push()
exprbuilder = ExprBuilder(self.asserts, self.query, self.solver)
self.solver.assertFormula(exprbuilder.query.cvc_expr)
smtlib = CVCWrapper._serialize(exprbuilder.query, exprbuilder.cvc_vars)
transformed_smtlib = [
self._transform(s) for s in sexpdata.parse(smtlib)
]
z3str2 = ""
for line in transformed_smtlib:
z3str2 += sexpdata.dumps(line, none_as='').strip().replace(
'\\\\', '\\') + "\n"
rawoutput = None
with NamedTemporaryFile(mode='w', suffix=".smt2") as f:
f.write(z3str2)
f.flush()
startime = time.clock()
try:
rawoutput = str(
check_output([
"timeout",
str(self.solvetimeout), "z3-str", "-f", f.name
],
universal_newlines=True))
except CalledProcessError as e:
if e.returncode == 124:
return "UNKNOWN", None
endtime = time.clock()
log.debug("Solver time: {0:.2f} seconds".format(endtime -
startime))
self.solvertime += endtime - startime
if ">> SAT" not in rawoutput:
return "UNSAT", None
model = {}
for name in exprbuilder.cvc_vars:
patterns = {
"{} : int -> (-?\d+)": int,
"{} : string -> \"([\S \\\\]*)\"": str
}
for pattern, constructor in patterns.items():
match = re.search(pattern.format(name), rawoutput)
if match is not None:
if constructor == str:
model[name] = bytes(constructor(match.group(1)),
"utf-8").decode("unicode_escape")
else:
model[name] = constructor(match.group(1))
return "SAT", model
def _transform(self, smtlib):
if isinstance(smtlib, Symbol) or isinstance(smtlib, int):
return smtlib
elif isinstance(smtlib, str):
smtlib = smtlib.replace('\\', '\\\\')
smtlib = smtlib.replace('\\\\v', '\\v')
smtlib = smtlib.replace('\\\\x', '\\x')
return smtlib
if isinstance(smtlib[0], list):
return [self._transform(subsmtlib) for subsmtlib in smtlib]
stmtname = smtlib[0].value()
if stmtname in ('set-logic', 'set-option'):
return None
elif stmtname == 'get-value':
return Symbol('get-model'),
elif stmtname == 'declare-fun':
declare, name, func, smttype = smtlib
return Symbol('declare-variable'), name, smttype
elif stmtname == 'str.prefixof':
stmtname, prefix, string = smtlib
return Symbol('StartsWith'), self._transform(
string), self._transform(prefix)
elif stmtname in Z3Str2Wrapper.rename:
return [Symbol(Z3Str2Wrapper.rename[stmtname])] + [
self._transform(subsmtlib) for subsmtlib in smtlib[1:]
]
elif len(smtlib) > 1:
return [smtlib[0]] + [
self._transform(subsmtlib) for subsmtlib in smtlib[1:]
]
return smtlib
@staticmethod
def _coneOfInfluence(asserts, query):
cone = []
cone_vars = set(query.getVars())
ws = [a for a in asserts if len(set(a.getVars()) & cone_vars) > 0]
remaining = [a for a in asserts if a not in ws]
while len(ws) > 0:
a = ws.pop()
a_vars = set(a.getVars())
cone_vars = cone_vars.union(a_vars)
cone.append(a)
new_ws = [
a for a in remaining if len(set(a.getVars()) & cone_vars) > 0
]
remaining = [a for a in remaining if a not in new_ws]
ws = ws + new_ws
return cone
class CVCWrapper(object):
options = {'produce-models': 'true',
# Enable experimental string support
'strings-exp': 'true',
# Enable modular arithmetic with constant modulus
'rewrite-divk': 'true',
'output-language': 'smt2',
'input-language': 'smt2'}
logic = 'ALL_SUPPORTED'
def __init__(self, query_store=None):
self.asserts = None
self.query = None
self.em = None
self.solver = None
self.query_store = query_store
self.smtlib = None
def findCounterexample(self, asserts, query, timeout=None):
"""Tries to find a counterexample to the query while
asserts remains valid."""
startime = time.process_time()
self.em = ExprManager()
self.solver = SmtEngine(self.em)
if timeout is not None:
self.options['tlimit-per'] = timeout*1000
for name, value in CVCWrapper.options.items():
self.solver.setOption(name, SExpr(str(value)))
self.solver.setLogic(CVCWrapper.logic)
self.query = query
self.asserts = asserts
result, model = self._findModel()
endtime = time.process_time()
log.debug("Timeout -- %s" % timeout)
log.debug("Result -- %s" % result)
log.debug("Model -- %s" % model)
log.debug("Solver time: {0:.2f} seconds".format(endtime - startime))
solvertime = endtime - startime
return result, model, solvertime
def _findModel(self):
self.solver.push()
exprbuilder = ExprBuilder(self.asserts, self.query, self.solver)
self.solver.assertFormula(exprbuilder.query.cvc_expr)
if self.query_store is not None:
self.smtlib = self._serialize(exprbuilder.query, exprbuilder.cvc_vars)
self._savequery()
model = None
try:
result = self.solver.checkSat()
if not result.isSat():
ret = "UNSAT"
elif result.isUnknown():
ret = "UNKNOWN"
elif result.isSat():
ret = "SAT"
model = self._getModel(exprbuilder.cvc_vars)
else:
raise Exception("Unexpected SMT result")
except RuntimeError as r:
log.debug("CVC exception %s" % r)
ret = "UNKNOWN"
except TypeError as t:
log.error("CVC exception %s" % t)
ret = "UNKNOWN"
self.solver.pop()
return ret, model
def _savequery(self):
if not path.isdir(self.query_store):
raise IOError("Query folder {} not found".format(self.query_store))
smthash = sha224(bytes(str(self.query), 'UTF-8')).hexdigest()
filename = path.join(self.query_store, "{}.smt2".format(smthash))
log.debug('Writing query to {}'.format(filename))
with open(filename, 'w') as f:
f.write(self.smtlib)
@staticmethod
def _serialize(query, variables):
smtlib_template = Template("""
(set-logic $logic)
(set-option :strings-exp ${strings_exp})
(set-option :produce-models ${produce_models})
(set-option :rewrite-divk ${rewrite_divk})
$declarevars
(assert $query)
(check-sat)
$getvars
""")
assignments = {name.replace('-', '_'): value for name, value in CVCWrapper.options.items()}
assignments['logic'] = CVCWrapper.logic
assignments['query'] = query
assignments['declarevars'] = "\n".join(
"(declare-fun {} () {})".format(name, var.CVC_TYPE) for name, var in variables.items())
assignments['getvars'] = "\n".join("(get-value ({}))".format(name) for name in variables)
return smtlib_template.substitute(assignments).strip()
@staticmethod
def _getModel(variables):
"""Retrieve the model generated for the path expression."""
return {name: cvc_var.getvalue() for (name, cvc_var) in variables.items()}
class CVCWrapper(object):
options = {
'produce-models': 'true',
# Enable experimental string support
'strings-exp': 'true',
# Enable modular arithmetic with constant modulus
'rewrite-divk': 'true',
# Per Query timeout of 5 seconds
'tlimit-per': 5000,
'output-language': 'smt2',
'input-language': 'smt2'
}
logic = 'ALL_SUPPORTED'
def __init__(self):
self.asserts = None
self.query = None
self.em = None
self.solver = None
def findCounterexample(self, asserts, query):
"""Tries to find a counterexample to the query while
asserts remains valid."""
self.em = ExprManager()
self.solver = SmtEngine(self.em)
for name, value in CVCWrapper.options.items():
self.solver.setOption(name, SExpr(str(value)))
self.solver.setLogic(CVCWrapper.logic)
self.query = query
self.asserts = self._coneOfInfluence(asserts, query)
result = self._findModel()
log.debug("Query -- %s" % self.query)
log.debug("Asserts -- %s" % asserts)
log.debug("Cone -- %s" % self.asserts)
log.debug("Result -- %s" % result)
return result
def _findModel(self):
self.solver.push()
exprbuilder = ExprBuilder(self.asserts, self.query, self.solver)
self.solver.assertFormula(exprbuilder.query.cvc_expr)
try:
result = self.solver.checkSat()
log.debug("Solver returned %s" % result.toString())
if not result.isSat():
ret = None
elif result.isUnknown():
ret = None
elif result.isSat():
ret = self._getModel(exprbuilder.cvc_vars)
else:
raise Exception("Unexpected SMT result")
except RuntimeError as r:
log.debug("CVC exception %s" % r)
ret = None
self.solver.pop()
return ret
@staticmethod
def _getModel(variables):
"""Retrieve the model generated for the path expression."""
return {
name: cvc_var.getvalue()
for (name, cvc_var) in variables.items()
}
@staticmethod
def _coneOfInfluence(asserts, query):
cone = []
cone_vars = set(query.getVars())
ws = [a for a in asserts if len(set(a.getVars()) & cone_vars) > 0]
remaining = [a for a in asserts if a not in ws]
while len(ws) > 0:
a = ws.pop()
a_vars = set(a.getVars())
cone_vars = cone_vars.union(a_vars)
cone.append(a)
new_ws = [
a for a in remaining if len(set(a.getVars()) & cone_vars) > 0
]
remaining = [a for a in remaining if a not in new_ws]
ws = ws + new_ws
return cone
class CVCWrapper(object):
options = {'produce-models': 'true',
# Enable experimental string support
'strings-exp': 'true',
# Enable modular arithmetic with constant modulus
'rewrite-divk': 'true',
# Per Query timeout of 5 seconds
'tlimit-per': 5000,
'output-language': 'smt2',
'input-language': 'smt2'}
logic = 'ALL_SUPPORTED'
def __init__(self):
self.asserts = None
self.query = None
self.em = None
self.solver = None
def findCounterexample(self, asserts, query):
"""Tries to find a counterexample to the query while
asserts remains valid."""
self.em = ExprManager()
self.solver = SmtEngine(self.em)
for name, value in CVCWrapper.options.items():
self.solver.setOption(name, SExpr(str(value)))
self.solver.setLogic(CVCWrapper.logic)
self.query = query
self.asserts = self._coneOfInfluence(asserts, query)
result = self._findModel()
log.debug("Query -- %s" % self.query)
log.debug("Asserts -- %s" % asserts)
log.debug("Cone -- %s" % self.asserts)
log.debug("Result -- %s" % result)
return result
def _findModel(self):
self.solver.push()
exprbuilder = ExprBuilder(self.asserts, self.query, self.solver)
self.solver.assertFormula(exprbuilder.query.cvc_expr)
try:
result = self.solver.checkSat()
log.debug("Solver returned %s" % result.toString())
if not result.isSat():
ret = None
elif result.isUnknown():
ret = None
elif result.isSat():
ret = self._getModel(exprbuilder.cvc_vars)
else:
raise Exception("Unexpected SMT result")
except RuntimeError as r:
log.debug("CVC exception %s" % r)
ret = None
self.solver.pop()
return ret
@staticmethod
def _getModel(variables):
"""Retrieve the model generated for the path expression."""
return {name: cvc_var.getvalue() for (name, cvc_var) in variables.items()}
@staticmethod
def _coneOfInfluence(asserts, query):
cone = []
cone_vars = set(query.getVars())
ws = [a for a in asserts if len(set(a.getVars()) & cone_vars) > 0]
remaining = [a for a in asserts if a not in ws]
while len(ws) > 0:
a = ws.pop()
a_vars = set(a.getVars())
cone_vars = cone_vars.union(a_vars)
cone.append(a)
new_ws = [a for a in remaining if len(set(a.getVars()) & cone_vars) > 0]
remaining = [a for a in remaining if a not in new_ws]
ws = ws + new_ws
return cone
