def test_symbolic_int(self): # Arrange name = 'TestVar1' z3_ctx = z3.Context() vsort = z3.IntSort(ctx=z3_ctx) value = 10 # Act var = SMTVar(name, vsort) var_before = var.var get_var_before = var.get_var() with self.assertRaises(RuntimeError): self.assertEquals(var.get_value(), value) # Concertize the value solver = z3.Solver(ctx=z3_ctx) solver.add(var.var == value) self.assertEquals(solver.check(), z3.sat) model = solver.model() var.eval(model) # Assert self.assertEquals(var.name, name) self.assertEquals(var.vsort, vsort) self.assertTrue(is_symbolic(var_before)) self.assertTrue(is_symbolic(get_var_before)) self.assertEquals(var.name, name) self.assertEquals(var.vsort, vsort) self.assertEquals(var.var, value) self.assertEquals(var.get_value(), value) self.assertTrue(is_symbolic(var.get_var()))
def reset(self, context=None): if context != None: self.context = context else: self.context = z3.Context() self.sort_dict = {} # sorts self.symbol_dict = {} # constant and function symbols
def _context(self): try: return self._tls.context except AttributeError: self._tls.context = z3.Context() if threading.current_thread( ).name != 'MainThread' else z3.main_ctx() return self._tls.context
def myExternalSolver(ctx, node, addr=None): """ The particularity of this sample is that we use an external solver to solve queries instead of using the internal Triton's solver (even if in both cases it uses z3). The point here is to show that Triton can provide generic smt2 outputs and theses outputs can be send to external solvers and get back model which then are sent to Triton. """ import z3 expr = ctx.newSymbolicExpression(node, "Custom for Solver") smtFormat = '(set-logic QF_BV) %s %s (check-sat) (get-model)' %(getVarSyntax(ctx), getSSA(ctx, expr)) c = z3.Context() s = z3.Solver(ctx=c) s.add(z3.parse_smt2_string(smtFormat, ctx=c)) if addr: debug('[+] Solving condition at %#x' %(addr)) if s.check() == z3.sat: ret = dict() model = s.model() for x in model: ret.update({int(str(x).split('_')[1], 10): int(str(model[x]), 10)}) return ret else: debug('[-] unsat :(') sys.exit(-1) return
def calculate_system(self, entity=None, include_subentities=True): logger.debug("FAST: Calculating for all entities") if not hasattr(self, "cache"): self.init_z3_constraints_and_vars() all_dts = [] # """ do the other things """ new_cache = translate_to_context(self.cache, z3.Context()) for influence in model.get_all_influences(entity): if self.contains_if_condition(influence): self.get_condition_change_enablers(influence, all_dts, new_cache) # updates = [up for up in get_updates(self.entity) if up.state == up._parent.current] for update in model.get_all_updates(entity): if update.state is update._parent.current: # only the currently active updates if self.contains_if_condition(update): self.get_condition_change_enablers(update, all_dts, new_cache) # TODO: check for transitions whether they can be done by time only for trans in model.get_all_transitions(entity): if trans._parent.current is trans.source: self.get_transition_time(trans, all_dts, new_cache) """ Return all behaviour change times """ return all_dts
def __init__(self, args): ctx = z3.Context() self.fp = z3.Fixedpoint(ctx=ctx) self.args = args self.log = LoggingManager.get_logger(__name__) self.prdes = None return
def test_symbolic_enum(self): # Arrange values = ['A', 'B', 'C'] sort_name = 'TestType' name = 'TestVar1' value = 'A' z3_ctx = z3.Context() vsort = EnumType(sort_name, values, z3_ctx=z3_ctx) # Act var = SMTVar(name, vsort) # Assert self.assertEquals(var.name, name) self.assertEquals(var.vsort, vsort) self.assertTrue(is_symbolic(var.var)) self.assertTrue(is_symbolic(var.get_var())) with self.assertRaises(RuntimeError): self.assertEquals(var.get_value(), 10) # Concertize the value solver = z3.Solver(ctx=z3_ctx) solver.add(var.var == vsort.get_symbolic_value(value)) self.assertEquals(solver.check(), z3.sat) model = solver.model() var.eval(model) self.assertEquals(var.name, name) self.assertEquals(var.vsort, vsort) self.assertEquals(var.var, vsort.get_symbolic_value(value)) self.assertEquals(var.get_value(), value) self.assertTrue(is_symbolic(var.get_var()))
def getCtx() -> z3.Context: global ctxHolder ctx = getattr(ctxHolder, "ctx", None) if (ctx == None): ctx = z3.Context() ctxHolder.ctx = ctx return ctx
def main(argv): args = parseArgs(argv[1:]) # get the names of inductive assumps first iass = set() cf = open(args.cert_mis_file) for line in cf: r = re.match("\s*\(\s*assert\s+(pre![^\)|^\s]+)", line) if r is not None: iass.add(r.group(1)) # now the invariants ctx = z3.Context() fmla = z3.parse_smt2_file(args.ass_inv_file, ctx=ctx) lemmas = [] assert z3.is_and(fmla), \ "invariant file should be a set of assertions" for l in fmla.children(): assert z3u.isZ3Implies(l), \ "assertions in the invariant file should be implications" name = str(l.arg(0).decl()) assert name.startswith("pre!"), \ "implicants in the invariant should start with pre!" if name in iass: lemmas.append(l.arg(1)) # dump the collected lemmas out = sys.stdout if args.out == '-' else open(args.out, 'w') z3u.to_smtlib(lemmas, out)
def checkSolver(self, stmt, endLine, expanderGenerator): """Check the given statement for correctness and return True if it is satisfyable.""" # Context Creation ctx = z3.Context() model = None check = None sat = False try: s = z3.Solver(ctx=ctx) if expanderGenerator is not None: stmt += expanderGenerator(ctx) expression = z3.parse_smt2_string(stmt, ctx=ctx) s.add(expression) check = s.check() sat = check.r > 0 if sat: model = s.model() except z3.Z3Exception as e: self.logger.error("Invalid SMT!") return sat, endLine, model, ctx, check
def chc_solve_with_fp(db, args, opts): if args.fresh: ctx = z3.Context() else: ctx = db.get_ctx() fp = z3.Fixedpoint(ctx=ctx) db.mk_fixedpoint(fp=fp) if args.st: fp.set("print_statistics", True) if args.pp: fp.set("xform.slice", True) fp.set("xform.inline_linear", True) fp.set("xform.inline_eager", True) else: fp.set("xform.slice", False) fp.set("xform.inline_linear", False) fp.set("xform.inline_eager", False) if args.spctr is not None: fp.set("spacer.trace_file", args.spctr) for k, v in opts.items(): fp.set(k, v) for q in db.get_queries(): qf = q.mk_query() if qf.ctx != ctx: qf = qf.translate(ctx) res = fp.query(qf) return res
def main(argv): print 'In main' args = parseArgs(argv[1:]) ctx = z3.Context() fmla = z3.parse_smt2_file(args.file, ctx=ctx) msg = 'Solving' if not args.no_blast: msg = msg + ' (blasted)' blasted = bitblast(fmla) else: blasted = fmla msg = msg + " ..." if args.o <> None: with open(args.o, 'w') as f: f.write(blasted.sexpr()) print msg solver = z3.Solver(ctx=ctx) solver.add(blasted) res = solver.check() print res return 0
def test_fresh_const_name(self): ctx = SolverContext(z3.Context()) name1 = ctx.fresh_constraint_name() name2 = ctx.fresh_constraint_name() self.assertTrue(isinstance(name1, basestring)) self.assertTrue(isinstance(name2, basestring)) self.assertFalse(name1 == name2)
def parallelRun(self, smt2_file): """ Job spanner """ ctx = z3.Context() fp = z3.Fixedpoint(ctx=ctx) jobs = [] with stats.timer('Parse'): self.log.info('Parsing ... ' + str(smt2_file)) queries = fp.parse_file(smt2_file) stats.stop('Parse') self.log.info("Parsing time ... " + str(stats.get('Parse')) + " ms") n_function = len(queries) n_query = n_function if self.args.func < 0 or self.args.func > n_function else self.args.func self.log.info("Number of functions ... " + str(n_function)) self.log.info("Number of jobs ... " + str(n_query)) all_results = "" pool_jobs = Pool(processes=n_query) try: for q in range(n_query): query = queries[q] function_name = self.getFunctionName(query) self.log.info("Checking feasibility of ... " + str(function_name)) #job_result = pool_jobs.apply_async(jobStarter, (self.args, qi, smt2_file, ), callback=self.onReturn) job_result = pool_jobs.apply_async(jobStarter, ( self.args, q, smt2_file, )) job_result.wait(timeout=self.args.timeout) if job_result.ready(): out = "" try: out = job_result.get() if bench: print out except Exception as e: print str(e) continue all_results += out + "\n-----------------------\n" else: out = out_message % (function_name, "TIMEOUT", "", "", "", "", "") out = bcolors.WARNING + out + bcolors.ENDC if bench: print out all_results += out + "\n------- ----------------\n" pool_jobs.close() pool_jobs.terminate() pool_jobs.join() if self.args.save: f_name = ntpath.basename(smt2_file) + "_feas.txt" with open(f_name, "w") as f: f.write(all_results) else: print "\n\t ========= SUMMARY SEAHORN INCONSISTENCY CHECKS ========" print all_results except Exception as e: self.log.exception(str(e))
def create_context(announcements, prefix_list=None, peer_list=None, as_path_list=None, next_hop_list=None, create_as_paths=True): """ Creates the SMT context that contains all the known announcements :return: SMTContext """ prefix_list = prefix_list if prefix_list else [] peer_list = peer_list if peer_list else [] as_path_list = as_path_list if as_path_list else [] as_path_list = [get_as_path_key(p) for p in as_path_list] next_hope_list = next_hop_list if next_hop_list else [] announcements = announcements if announcements else [] assert announcements, "No announcements defined to extract context from" ctx = SolverContext(z3.Context()) # Prefixes read_list = [x.prefix for x in announcements if not is_empty(x.prefix)] prefix_list = list(set(read_list + prefix_list)) prefix_list = [sanitize_smt_name(prefix) for prefix in prefix_list] ctx.create_enum_type(PREFIX_SORT, prefix_list) # Peers read_list = [x.peer for x in announcements if not is_empty(x.peer)] peer_list = list(set(read_list + peer_list)) ctx.create_enum_type(PEER_SORT, peer_list) # BGP announcement origins origin_list = BGP_ATTRS_ORIGIN.__members__.keys() ctx.create_enum_type(BGP_ORIGIN_SORT, origin_list) # AS path list if create_as_paths: read_list = [ get_as_path_key(x.as_path) for x in announcements if not is_empty(x.as_path) ] as_path_list = list(set(read_list + as_path_list)) ctx.create_enum_type(ASPATH_SORT, as_path_list) # Next Hop read_list = [ x.next_hop for x in announcements if not is_empty(x.next_hop) ] origin_next_hop = '0.0.0.0' read_list.append(origin_next_hop) next_hope_list = list(set(read_list + next_hope_list)) next_hope_list = [ sanitize_smt_name(next_hop) for next_hop in next_hope_list ] vsort = ctx.create_enum_type(NEXT_HOP_SORT, next_hope_list) ctx.communities = announcements[0].communities.keys() ctx.origin_next_hop = sanitize_smt_name(origin_next_hop) ctx.origin_next_hop_var = vsort.get_symbolic_value(ctx.origin_next_hop) return ctx
def solve_and_proof(tm): """Use veriT to determine whether a logical term is satisfiable.""" s = z3wrapper.solve_core(z3.Solver(ctx=z3.Context()) ,tm, False) with open("proof.smt2", "a") as f: f.seek(0) f.truncate() f.write("(set-logic LRA)\n" + s.to_smt2()) proof_rec("proof.smt2")
def test_create_var_prefix(self): # Arrange ctx = SolverContext(z3.Context()) prefix = 'CustPrefix' # Act var = ctx.create_fresh_var(z3.IntSort(), value=10, name_prefix=prefix) # Assert self.assertTrue(isinstance(var, SMTVar)) self.assertTrue(var.name.startswith(prefix))
def parse_exp(exp_name): exp_folder = os.path.join(MEDIA, exp_name) nodes_list = [] run_cmd = "" stdout = safe_read(os.path.join(exp_folder, "stdout")) stderr = safe_read(os.path.join(exp_folder, "stderr")) spacer_log = safe_read(os.path.join(exp_folder, "spacer.log")) run_cmd = safe_read(os.path.join(exp_folder, "run_cmd"))[0].strip() temp_var_names = safe_read(os.path.join(exp_folder, "var_names")) var_names = temp_var_names[0].strip() if temp_var_names != [] else "" expr_map = get_expr_map(exp_name) rels = [] status = "success" spacer_state = get_spacer_state(stderr, stdout) #generate var_decls try: print("trying to parse input") new_context = z3.Context() new_env = pysmt.environment.Environment() db = H.load_horn_db_from_file( os.path.join(exp_folder, "input_file.smt2"), new_context, new_env) print("done load horndb") for rel_name in db._rels: rel = db.get_rel(rel_name) rels.append(rel) with open(os.path.join(exp_folder, "var_decls"), "w") as f: for rel in rels: save_var_rels(rel, f) print("done parsing input") except: traceback.print_exc() status = "error in loading horndb. skip parsing the file" print(status) #parse events nodes_list = parse(spacer_log) res = { 'status': status, 'spacer_state': spacer_state, 'nodes_list': nodes_list, 'run_cmd': run_cmd, 'var_names': var_names, 'expr_map': expr_map } #write to db if spacer_state != "running": try: insert_db( 'REPLACE INTO nodes_list(exp_name, nodes_list) VALUES (?,?)', (exp_name, json.dumps(res))) except: traceback.print_exc() return res
def __init__(self, *args, **kwargs): # z3.set_param(auto_config=False) # http://stackoverflow.com/questions/18770582/z3-offering-random-solutions-in-solving # z3.set_param('smt.phase_selection',0) # z3.set_param('smt.random_seed',0) import os z3.init(os.getenv('Z3_LIBRARY_PATH', '.')) self.context_obj = z3.Context(*args, **kwargs) self.interpretation_map = {} self.solvers = []
def test_register_var(self): name = 'TestVar1' vsort = z3.IntSort() var = SMTVar(name, vsort) ctx = SolverContext(z3.Context()) ctx._register_var(var) self.assertTrue(var.name in ctx._vars) with self.assertRaises(ValueError): ctx._register_var(var)
def main(argv): args = parseArgs(argv[1:]) stat('Result', 'UNKNOWN') ctx = z3.Context() fp = z3.Fixedpoint(ctx=ctx) zus = Zustre(args, ctx, fp) if args.no_solving: zus.encode() else: zus.encodeAndSolve()
def __init__(self, args): verbose = args.verbose self.args = args self.ctx = z3.Context() self.fp = z3.Fixedpoint(ctx=self.ctx) self.preds = [] self.ee_idx = [] #entry/exit vars self.feasible_flag = [] # keep track of the feasible path self.non_feasible_flag = [] # keep track of the infesible path return
def test_fresh_const_name_prefix(self): # Arrange ctx = SolverContext(z3.Context()) prefix = 'CustPrefix' # Act name1 = ctx.fresh_constraint_name(prefix=prefix) name2 = ctx.fresh_constraint_name(prefix=prefix) # Assert self.assertTrue(isinstance(name1, basestring)) self.assertTrue(isinstance(name2, basestring)) self.assertFalse(name1 == name2) self.assertTrue(name1.startswith(prefix)) self.assertTrue(name2.startswith(prefix))
def test_get_constraints(self): var1 = SMTVar('var1', z3.IntSort()) var2 = SMTVar('var1', z3.IntSort()) const = var1.var + var2.var > 10 name = 'cosnt1' ctx = SolverContext(z3.Context()) ctx.register_constraint(const, name) self.assertIsNotNone(ctx.get_constraint(name)) self.assertIsNotNone(ctx.get_constraints_info(name)) with self.assertRaises(ValueError): ctx.get_constraint('NotRegistered') with self.assertRaises(ValueError): ctx.get_constraints_info('NotRegistered')
def cmd(n, m, i, output_dir, dims, timeout, incremental, copy_last): """Assume that an NxM matrix is encoded as a binary number and is passed as I. Try to see whether the scoring pattern can be fit into 2D and save the output embeddings, if it can be.""" output_dir = os.path.join(output_dir, f'{i}') os.makedirs(output_dir, exist_ok=True) output_file = os.path.join(output_dir, f'{dims}D.out') prev_output_file = os.path.join(output_dir, '{}D.out'.format(dims - 1)) if os.path.exists(output_file) and incremental: print( 'Not running for m={}, n={}, i={} as the file {} already exists.'. format(m, n, i, output_file)) else: solved = False if os.path.exists(prev_output_file) and copy_last: with open(prev_output_file) as f: prev_dim_res = f.readline().strip() if prev_dim_res == 'sat': with open(output_file, 'wt') as f: f.write('sat') solved = True if not solved: M = i_to_M(n, m, i) voting_pats = D.sign_mat_to_voting_pats(M) ctx = z3.Context() prob, c_vars, v_vars = D.create_z3_prob( ctx=ctx, n_dim=dims, voting_patterns=voting_pats) prob.set('timeout', timeout) res = prob.check() if str(res) == 'sat': c_vec, v_vec = D.make_vectors_from_z3_soln(prob=prob, c_vars=c_vars, v_vars=v_vars) c_file = output_file + '.c_vecs' v_file = output_file + '.v_vecs' np.savetxt(c_file, c_vec) np.savetxt(v_file, v_vec) with open(output_file, 'wt') as f: f.write(str(res))
def _worker(key_idx): k_id = key_ids[key_idx] M = D.make_M_from_df_generic(df=df, key_name=key, key_value=k_id) voting_pats = D.sign_mat_to_voting_pats(M) unique_voting_pats = list(set(tuple(x) for x in voting_pats)) ctx = z3.Context() prob, _, _ = D.create_z3_prob(ctx=ctx, n_dim=n_dims, voting_patterns=unique_voting_pats) prob.set('timeout', timeout) res = prob.check() return {key: k_id, '{}D_sat'.format(n_dims): str(res)}
def singleRun(self, smt2_file): """ Single run """ ctx = z3.Context() fp = z3.Fixedpoint(ctx=ctx) with stats.timer('Parse'): self.log.info('Parsing ... ' + str(smt2_file)) queries = fp.parse_file(smt2_file) stats.stop('Parse') self.log.info("Parsing time ... " + str(stats.get('Parse')) + " ms") n_function = len(queries) n_query = n_function if self.args.func < 0 or self.args.func > n_function else self.args.func self.log.info("Number of functions ... " + str(n_function)) self.log.info("Number of jobs ... " + str(n_query)) all_results = "" try: for q in range(n_query): query = queries[q] function_name = self.getFunctionName(query) self.log.info("Checking feasibility of ... " + str(function_name)) out = "" try: p = multiprocessing.Process(target=checkFeas, args=( self.args, q, smt2_file, )) p.start() p.join(self.args.timeout) if p.is_alive(): out = out_message % (function_name, "TIMEOUT", "", "", "", "", "") out = bcolors.WARNING + out + bcolors.ENDC p.terminate() p.join() except Exception as e: self.log.exception(str(e)) continue all_results += out + "\n-----------------------\n" if self.args.save: f_name = ntpath.basename(smt2_file) + "_feas.txt" with open(f_name, "w") as f: f.write(all_results) except Exception as e: self.log.exception(str(e))
def test_create_enum_type(self): # Arrange values = ['A', 'B', 'C'] sort_name = 'TestType' ctx = SolverContext(z3.Context()) # Act vsort = ctx.create_enum_type(sort_name, values) # Assert self.assertTrue(isinstance(vsort, EnumType)) self.assertEquals(vsort.name, sort_name) self.assertEquals(vsort.concrete_values, values) with self.assertRaises(ValueError): ctx.create_enum_type(sort_name, values) with self.assertRaises(ValueError): ctx.create_enum_type("name2", values)
def __init__(self, args, smt2_file): log = 3 if verbose else 0 self.log = LoggingManager.get_logger(__name__, log) self.smt2_file = smt2_file self.args = args self.ctx = z3.Context() self.fp = z3.Fixedpoint(ctx=self.ctx) self.ee_idx = list() #entry/exit vars self.feasible_flag = set() # keep track of the feasible path self.non_feasible_flag = set() # keep track of the infesible path self.timeout = args.timeout # timeout per function self.flags = None self.preds = None self.function_name = None self.query_times = list()
def test_concrete_enum(self): # Arrange values = ['A', 'B', 'C'] sort_name = 'TestType' name = 'TestVar1' value = 'A' z3_ctx = z3.Context() vsort = EnumType(sort_name, values, z3_ctx=z3_ctx) # Act var = SMTVar(name, vsort, value) # Assert self.assertEquals(var.name, name) self.assertEquals(var.vsort, vsort) self.assertEquals(var.var, vsort.get_symbolic_value(value)) self.assertEquals(var.get_value(), value) self.assertTrue(is_symbolic(var.get_var()))