static Z3_apply_result _tactic_apply(Z3_context c, Z3_tactic t, Z3_goal g, params_ref p) { goal_ref new_goal; new_goal = alloc(goal, *to_goal_ref(g)); Z3_apply_result_ref * ref = alloc(Z3_apply_result_ref, mk_c(c)->m()); mk_c(c)->save_object(ref); unsigned timeout = p.get_uint("timeout", UINT_MAX); bool use_ctrl_c = p.get_bool("ctrl_c", false); cancel_eh<reslimit> eh(mk_c(c)->m().limit()); to_tactic_ref(t)->updt_params(p); api::context::set_interruptable si(*(mk_c(c)), eh); { scoped_ctrl_c ctrlc(eh, false, use_ctrl_c); scoped_timer timer(timeout, &eh); try { exec(*to_tactic_ref(t), new_goal, ref->m_subgoals, ref->m_mc, ref->m_pc, ref->m_core); return of_apply_result(ref); } catch (z3_exception & ex) { mk_c(c)->handle_exception(ex); return 0; } } }
void updt_params(params_ref const & p) { m_max_memory = megabytes_to_bytes(p.get_uint("max_memory", UINT_MAX)); m_max_steps = p.get_uint("max_steps", UINT_MAX); m_blast_add = p.get_bool("blast_add", true); m_blast_mul = p.get_bool("blast_mul", true); m_blast_full = p.get_bool("blast_full", false); m_blast_quant = p.get_bool("blast_quant", false); m_blaster.set_max_memory(m_max_memory); }
static void show_interpolant_and_maybe_check(cmd_context & ctx, ptr_vector<ast> &cnsts, expr *t, ptr_vector<ast> &interps, params_ref &m_params, bool check) { if (m_params.get_bool("som", false)) m_params.set_bool("flat", true); th_rewriter s(ctx.m(), m_params); for(unsigned i = 0; i < interps.size(); i++){ expr_ref r(ctx.m()); proof_ref pr(ctx.m()); s(to_expr(interps[i]),r,pr); ctx.regular_stream() << mk_pp(r.get(), ctx.m()) << std::endl; #if 0 ast_smt_pp pp(ctx.m()); pp.set_logic(ctx.get_logic().str().c_str()); pp.display_smt2(ctx.regular_stream(), to_expr(interps[i])); ctx.regular_stream() << std::endl; #endif } s.cleanup(); // verify, for the paranoid... if(check || interp_params(m_params).check()){ std::ostringstream err; ast_manager &_m = ctx.m(); // need a solver -- make one here FIXME is this right? bool proofs_enabled, models_enabled, unsat_core_enabled; params_ref p; ctx.params().get_solver_params(_m, p, proofs_enabled, models_enabled, unsat_core_enabled); scoped_ptr<solver> sp = (ctx.get_solver_factory())(_m, p, false, true, false, ctx.get_logic()); if(iz3check(_m,sp.get(),err,cnsts,t,interps)) ctx.regular_stream() << "correct\n"; else ctx.regular_stream() << "incorrect: " << err.str().c_str() << "\n"; } for(unsigned i = 0; i < interps.size(); i++){ ctx.m().dec_ref(interps[i]); } interp_params itp_params(m_params); if(itp_params.profile()) profiling::print(ctx.regular_stream()); }
void sls_engine::updt_params(params_ref const & _p) { sls_params p(_p); m_produce_models = _p.get_bool("model", false); m_max_restarts = p.max_restarts(); m_tracker.set_random_seed(p.random_seed()); m_walksat = p.walksat(); m_walksat_repick = p.walksat_repick(); m_paws_sp = p.paws_sp(); m_paws = m_paws_sp < 1024; m_wp = p.wp(); m_vns_mc = p.vns_mc(); m_vns_repick = p.vns_repick(); m_restart_base = p.restart_base(); m_restart_next = m_restart_base; m_restart_init = p.restart_init(); m_early_prune = p.early_prune(); m_random_offset = p.random_offset(); m_rescore = p.rescore(); // Andreas: Would cause trouble because repick requires an assertion being picked before which is not the case in GSAT. if (m_walksat_repick && !m_walksat) NOT_IMPLEMENTED_YET(); if (m_vns_repick && !m_walksat) NOT_IMPLEMENTED_YET(); }
void updt_params(params_ref const & _p) { sls_params p(_p); m_produce_models = _p.get_bool("model", false); m_max_restarts = p.restarts(); m_tracker.set_random_seed(p.random_seed()); m_plateau_limit = p.plateau_limit(); }
void dl_query_test_wpa(smt_params & fparams, params_ref& params) { params.set_bool("magic_sets_for_queries", true); ast_manager m; random_gen ran(0); reg_decl_plugins(m); arith_util arith(m); const char * problem_dir = "C:\\tvm\\src\\z3_2\\debug\\test\\w0.datalog"; dl_decl_util dl_util(m); std::cerr << "Testing queries on " << problem_dir <<"\n"; register_engine re; context ctx(m, re, fparams); ctx.updt_params(params); { wpa_parser* p = wpa_parser::create(ctx, m); TRUSTME( p->parse_directory(problem_dir) ); dealloc(p); } const unsigned attempts = 10; func_decl * v_pred = ctx.try_get_predicate_decl(symbol("V")); SASSERT(v_pred); sort * var_sort = v_pred->get_domain(0); uint64 var_sz; TRUSTME( ctx.try_get_sort_constant_count(var_sort, var_sz) ); for(unsigned attempt=0; attempt<attempts; attempt++) { unsigned el1 = ran()%var_sz; unsigned el2 = ran()%var_sz; expr_ref_vector q_args(m); q_args.push_back(dl_util.mk_numeral(el1, var_sort)); q_args.push_back(dl_util.mk_numeral(el2, var_sort)); app_ref query_lit(m.mk_app(v_pred, q_args.c_ptr()), m); lbool is_sat = ctx.query(query_lit); SASSERT(is_sat != l_undef); bool found = is_sat == l_true; std::cerr<<"query finished: "<<found<<"\n"; relation_fact ans_fact(m); ans_fact.push_back(to_app(q_args.back())); q_args.pop_back(); q_args.push_back(m.mk_var(0, var_sort)); query_lit = m.mk_app(v_pred, q_args.c_ptr()); is_sat = ctx.query(query_lit.get()); SASSERT(is_sat != l_false); std::cerr<<"non-ground query finished\n"; if(ctx.result_contains_fact(ans_fact)!=found) { std::cerr<<"wrong wpa answer!\n"; UNREACHABLE(); } } }
params_ref context_params::merge_default_params(params_ref const & p) { if (!m_auto_config && !p.contains("auto_config")) { params_ref new_p = p; new_p.set_bool("auto_config", false); return new_p; } else { return p; } }
void reset() { #pragma omp critical (gparams) { m_params.reset(); for (auto & kv : m_module_params) { dealloc(kv.m_value); } m_module_params.reset(); } }
void smt_params::updt_local_params(params_ref const & _p) { smt_params_helper p(_p); m_auto_config = p.auto_config() && gparams::get_value("auto_config") == "true"; // auto-config is not scoped by smt in gparams. m_random_seed = p.random_seed(); m_relevancy_lvl = p.relevancy(); m_ematching = p.ematching(); m_phase_selection = static_cast<phase_selection>(p.phase_selection()); m_restart_strategy = static_cast<restart_strategy>(p.restart_strategy()); m_restart_factor = p.restart_factor(); m_case_split_strategy = static_cast<case_split_strategy>(p.case_split()); m_delay_units = p.delay_units(); m_delay_units_threshold = p.delay_units_threshold(); m_preprocess = _p.get_bool("preprocess", true); // hidden parameter m_soft_timeout = p.soft_timeout(); model_params mp(_p); m_model_compact = mp.compact(); if (_p.get_bool("arith.greatest_error_pivot", false)) m_arith_pivot_strategy = ARITH_PIVOT_GREATEST_ERROR; else if (_p.get_bool("arith.least_error_pivot", false)) m_arith_pivot_strategy = ARITH_PIVOT_LEAST_ERROR; theory_array_params::updt_params(_p); }
std::string get_value(char const * name) { std::string r; bool error = false; std::string error_msg; #pragma omp critical (gparams) { try { symbol m, p; normalize(name, m, p); if (m == symbol::null) { if (m_params.contains(p)) { r = get_value(m_params, p); } else { r = get_default(get_param_descrs(), p, m); } } else { params_ref * ps = nullptr; if (m_module_params.find(m, ps) && ps->contains(p)) { r = get_value(*ps, p); } else { param_descrs * d; if (get_module_param_descrs().find(m, d)) { r = get_default(*d, p, m); } else { std::stringstream strm; strm << "unknown module '" << m << "'"; throw exception(strm.str()); } } } } catch (z3_exception & ex) { // Exception cannot cross critical section boundaries. error = true; error_msg = ex.msg(); } } if (error) throw exception(std::move(error_msg)); return r; }
std::string get_value(params_ref const & ps, symbol const & p) { std::ostringstream buffer; ps.display(buffer, p); return buffer.str(); }
virtual void updt_params(params_ref const & p) { m_max_memory = megabytes_to_bytes(p.get_uint("max_memory", UINT_MAX)); m_aig_gate_encoding = p.get_bool("aig_default_gate_encoding", true); m_aig_per_assertion = p.get_bool("aig_per_assertion", true); }
void context_params::updt_params(params_ref const & p) { m_timeout = p.get_uint("timeout", UINT_MAX); m_well_sorted_check = p.get_bool("type_check", p.get_bool("well_sorted_check", true)); m_auto_config = p.get_bool("auto_config", true); m_proof = p.get_bool("proof", false); m_model = p.get_bool("model", true); m_model_validate = p.get_bool("model_validate", false); m_trace = p.get_bool("trace", false); m_trace_file_name = p.get_str("trace_file_name", "z3.log"); m_unsat_core = p.get_bool("unsat_core", false); m_debug_ref_count = p.get_bool("debug_ref_count", false); m_smtlib2_compliant = p.get_bool("smtlib2_compliant", false); }
double params_ref::get_double(char const * k, params_ref const & fallback, double _default) const { return m_params ? m_params->get_double(k, fallback, _default) : fallback.get_double(k, _default); }
void updt_params(params_ref const & p) { m_fparams.m_nlquant_elim = p.get_bool(":qe-nonlinear", false); m_qe.updt_params(p); }
/** Update front_end_params using s. Only the most frequently used options are updated. This function is mainly used to allow smt::context to be used in the new strategy framework. */ void params2front_end_params(params_ref const & s, front_end_params & t) { t.m_quant_elim = s.get_bool(":elim-quant", t.m_quant_elim); t.m_relevancy_lvl = s.get_uint(":relevancy", t.m_relevancy_lvl); TRACE("qi_cost", s.display(tout); tout << "\n";);
void context_params::get_solver_params(ast_manager const & m, params_ref & p, bool & proofs_enabled, bool & models_enabled, bool & unsat_core_enabled) { proofs_enabled = m.proofs_enabled() && p.get_bool("proof", m_proof); models_enabled = p.get_bool("model", m_model); unsat_core_enabled = p.get_bool("unsat_core", m_unsat_core); p = merge_default_params(p); }
void updt_params_core(params_ref const & p) { m_normalize_int_only = p.get_bool("norm_int_only", true); }
bool params_ref::get_bool(char const * k, params_ref const & fallback, bool _default) const { return m_params ? m_params->get_bool(k, fallback, _default) : fallback.get_bool(k, _default); }
void fpa2bv_rewriter_cfg::updt_params(params_ref const & p) { m_max_memory = megabytes_to_bytes(p.get_uint("max_memory", UINT_MAX)); m_max_steps = p.get_uint("max_steps", UINT_MAX); updt_local_params(p); }
symbol params_ref::get_sym(char const * k, params_ref const & fallback, symbol const & _default) const { return m_params ? m_params->get_sym(k, fallback, _default) : fallback.get_sym(k, _default); }
void bv2int_rewriter_ctx::update_params(params_ref const& p) { m_max_size = p.get_uint("max_bv_size", UINT_MAX); }
void updt_params_core(params_ref const & p) { m_partial_lia2pb = p.get_bool("lia2pb_partial", false); m_max_bits = p.get_uint("lia2pb_max_bits", 32); m_total_bits = p.get_uint("lia2pb_total_bits", 2048); }
void bound_propagator::updt_params(params_ref const & p) { m_max_refinements = p.get_uint("bound_max_refinements", 16); m_threshold = p.get_double("bound_threshold", 0.05); m_small_interval = p.get_double("bound_small_interval", 128); m_strict2double = p.get_double("strict2double", 0.00001); }
void dl_query_test(ast_manager & m, smt_params & fparams, params_ref& params, context & ctx_b, char const* problem_file, unsigned test_count, bool use_magic_sets) { dl_decl_util decl_util(m); random_gen ran(0); register_engine re; context ctx_q(m, re, fparams); params.set_bool("magic_sets_for_queries", use_magic_sets); ctx_q.updt_params(params); { parser* p = parser::create(ctx_q,m); TRUSTME( p->parse_file(problem_file) ); dealloc(p); } relation_manager & rel_mgr_q = ctx_b.get_rel_context()->get_rmanager(); decl_set out_preds = ctx_b.get_rules().get_output_predicates(); decl_set::iterator it = out_preds.begin(); decl_set::iterator end = out_preds.end(); for(; it!=end; ++it) { func_decl * pred_b = *it; std::cerr << "Checking queries on relation " << pred_b->get_name() << "\n"; func_decl * pred_q = ctx_q.try_get_predicate_decl(symbol(pred_b->get_name().bare_str())); SASSERT(pred_q); relation_base & rel_b = ctx_b.get_rel_context()->get_relation(pred_b); relation_signature sig_b = rel_b.get_signature(); relation_signature sig_q = ctx_q.get_rel_context()->get_relation(pred_q).get_signature(); SASSERT(sig_b.size()==sig_q.size()); std::cerr << "Queries on random facts...\n"; relation_fact f_b(m); relation_fact f_q(m); for(unsigned attempt=0; attempt<test_count; attempt++) { f_b.reset(); f_q.reset(); for(unsigned col=0; col<sig_b.size(); col++) { uint64 sort_sz; if(!decl_util.try_get_size(sig_q[col], sort_sz)) { warning_msg("cannot get sort size"); return; } uint64 num = ran()%sort_sz; app * el_b = decl_util.mk_numeral(num, sig_b[col]); f_b.push_back(el_b); app * el_q = decl_util.mk_numeral(num, sig_q[col]); f_q.push_back(el_q); } bool found_in_b = rel_b.contains_fact(f_b); dl_query_ask_ground_query(ctx_q, pred_q, f_q, found_in_b); dl_query_ask_for_last_arg(ctx_q, pred_q, f_q, found_in_b); } std::cerr << "Queries on table facts...\n"; if(!rel_b.from_table()) { warning_msg("relation is not a table_relation, skipping queries on facts"); } table_relation & tr_b = static_cast<table_relation &>(rel_b); table_base & table_b = tr_b.get_table(); table_fact tf; unsigned table_sz = table_b.get_size_estimate_rows(); table_base::iterator fit = table_b.begin(); table_base::iterator fend = table_b.end(); for(; fit!=fend; ++fit) { if(ran()%std::max(1u,table_sz/test_count)!=0) { continue; } fit->get_fact(tf); rel_mgr_q.table_fact_to_relation(sig_q, tf, f_q); dl_query_ask_ground_query(ctx_q, pred_q, f_q, true); dl_query_ask_for_last_arg(ctx_q, pred_q, f_q, true); } std::cerr << "Done.\n"; } }
void test_finite_product_relation(smt_params fparams, params_ref& params) { ast_manager m; register_engine re; context ctx(m, re, fparams); ctx.updt_params(params); dl_decl_util dl_util(m); relation_manager & rmgr = ctx.get_rel_context()->get_rmanager(); relation_plugin & rel_plugin = *rmgr.get_relation_plugin(params.get_sym("default_relation", symbol("sparse"))); ENSURE(&rel_plugin); finite_product_relation_plugin plg(rel_plugin, rmgr); sort_ref byte_srt_ref(dl_util.mk_sort(symbol("BYTE"), 256), m); relation_sort byte_srt = byte_srt_ref; relation_signature sig2; sig2.push_back(byte_srt); sig2.push_back(byte_srt); relation_signature sig3(sig2); sig3.push_back(byte_srt); relation_signature sig4(sig3); sig4.push_back(byte_srt); app_ref seven_ref(dl_util.mk_numeral(7, byte_srt), m); app_ref nine_ref(dl_util.mk_numeral(9, byte_srt), m); relation_element seven = seven_ref; relation_element nine = nine_ref; relation_fact f7(m); f7.push_back(seven); relation_fact f9(m); f9.push_back(nine); relation_fact f77(f7); f77.push_back(seven); relation_fact f79(f7); f79.push_back(nine); relation_fact f97(f9); f97.push_back(seven); relation_fact f99(f9); f99.push_back(nine); relation_fact f779(f77); f779.push_back(nine); relation_fact f799(f79); f799.push_back(nine); relation_fact f977(f97); f977.push_back(seven); relation_fact f7797(f779); f7797.push_back(seven); relation_fact f7997(f799); f7997.push_back(seven); bool table_cols2[] = { true, false }; bool table_cols3[] = { true, false, false }; bool table_cols4[] = { true, true, false, false }; scoped_rel<relation_base> r1 = plg.mk_empty(sig2, table_cols2); scoped_rel<relation_base> r2 = r1->clone(); scoped_rel<relation_base> r3 = r2->clone(); ENSURE(!r1->contains_fact(f77)); r1->add_fact(f77); ENSURE(r1->contains_fact(f77)); r2->add_fact(f79); r3->add_fact(f99); r2->display( std::cout << "r2 0\n"); scoped_rel<relation_base> r4 = r2->clone(); r2->display( std::cout << "r2 1\n"); r4->display( std::cout << "r4 0\n"); ENSURE(!r4->contains_fact(f77)); ENSURE(r4->contains_fact(f79)); r4->add_fact(f77); r4->display( std::cout << "r4 1\n"); ENSURE(r4->contains_fact(f77)); ENSURE(r4->contains_fact(f79)); r4->add_fact(f99); r4->display( std::cout << "r4 2\n"); ENSURE(r4->contains_fact(f99)); std::cout << "------ testing union ------\n"; r2->display( std::cout << "r2\n"); scoped_ptr<relation_union_fn> union_op = rmgr.mk_union_fn(*r1, *r2, r3.get()); ENSURE(union_op); (*union_op)(*r1, *r2, r3.get()); r1->display( std::cout << "r1\n"); r2->display( std::cout << "r2\n"); r3->display( std::cout << "r3\n"); ENSURE(r1->contains_fact(f77)); ENSURE(r1->contains_fact(f79)); ENSURE(!r1->contains_fact(f99)); ENSURE(!r3->contains_fact(f77)); ENSURE(r3->contains_fact(f79)); ENSURE(r3->contains_fact(f99)); std::cout << "------ testing join ------\n"; r1->reset(); r1->add_fact(f77); r1->add_fact(f79); r1->add_fact(f97); r2->reset(); r2->add_fact(f97); r2->add_fact(f99); unsigned col0[] = { 0 }; unsigned col1[] = { 1 }; scoped_ptr<relation_join_fn> join_tt = rmgr.mk_join_fn(*r1, *r2, 1, col0, col0); scoped_ptr<relation_join_fn> join_tr = rmgr.mk_join_fn(*r1, *r2, 1, col0, col1); scoped_ptr<relation_join_fn> join_rr = rmgr.mk_join_fn(*r1, *r2, 1, col1, col1); r1->display( std::cout << "r1\n"); r2->display( std::cout << "r2\n"); scoped_rel<relation_base> jr_tt = (*join_tt)(*r1, *r2); scoped_rel<relation_base> jr_tr = (*join_tr)(*r1, *r2); scoped_rel<relation_base> jr_rr = (*join_rr)(*r1, *r2); jr_tt->display( std::cout << "tt\n"); jr_tr->display( std::cout << "tr\n"); jr_rr->display( std::cout << "rr\n"); ENSURE(!jr_tt->contains_fact(f7797)); ENSURE(jr_tr->contains_fact(f7797)); ENSURE(jr_rr->contains_fact(f7797)); std::cout << "------ testing project ------\n"; scoped_rel<relation_base> r31 = plg.mk_empty(sig3, table_cols3); r31->add_fact(f779); r31->add_fact(f977); r31->add_fact(f799); unsigned rem_1_rel[] = { 1 }; unsigned rem_2_rel[] = { 1, 2 }; unsigned rem_1_table[] = { 0 }; scoped_ptr<relation_transformer_fn> proj_1r = rmgr.mk_project_fn(*r31, 1, rem_1_rel); scoped_ptr<relation_transformer_fn> proj_2r = rmgr.mk_project_fn(*r31, 2, rem_2_rel); scoped_ptr<relation_transformer_fn> proj_1t = rmgr.mk_project_fn(*r31, 1, rem_1_table); scoped_rel<relation_base> sr_1r = (*proj_1r)(*r31); scoped_rel<relation_base> sr_2r = (*proj_2r)(*r31); scoped_rel<relation_base> sr_1t = (*proj_1t)(*r31); ENSURE(sr_1r->contains_fact(f79)); ENSURE(sr_1r->contains_fact(f97)); ENSURE(!sr_1r->contains_fact(f77)); ENSURE(sr_2r->contains_fact(f7)); ENSURE(sr_2r->contains_fact(f9)); ENSURE(sr_1t->contains_fact(f79)); ENSURE(!sr_1t->contains_fact(f97)); ENSURE(sr_1t->contains_fact(f77)); ENSURE(sr_1t->contains_fact(f99)); std::cout << "------ testing filter_interpreted ------\n"; scoped_rel<relation_base> r41 = plg.mk_empty(sig4, table_cols4); r41->add_fact(f7797); r41->add_fact(f7997); app_ref cond(m.mk_and( m.mk_not(m.mk_eq(m.mk_var(1,byte_srt), m.mk_var(2,byte_srt))), //#1!=#2 m.mk_not(m.mk_eq(m.mk_var(3,byte_srt), m.mk_var(2,byte_srt))) //#3!=#2 ), m); scoped_ptr<relation_mutator_fn> i_filter = rmgr.mk_filter_interpreted_fn(*r41, cond); (*i_filter)(*r41); ENSURE(r41->contains_fact(f7797)); ENSURE(!r41->contains_fact(f7997)); std::cout << "------ testing filter_by_negation ------\n"; r31->reset(); r31->add_fact(f779); r31->add_fact(f977); r31->add_fact(f799); r1->reset(); r1->add_fact(f77); r1->add_fact(f79); unsigned nf_r31_cols[] = {1, 0, 1}; unsigned nf_r1_cols[] = {0, 0, 1}; scoped_ptr<relation_intersection_filter_fn> neg_filter = rmgr.mk_filter_by_negation_fn(*r31, *r1, 3, nf_r31_cols, nf_r1_cols); (*neg_filter)(*r31, *r1); ENSURE(!r31->contains_fact(f779)); ENSURE(r31->contains_fact(f977)); ENSURE(r31->contains_fact(f799)); }
unsigned params_ref::get_uint(char const * k, params_ref const & fallback, unsigned _default) const { return m_params ? m_params->get_uint(k, fallback, _default) : fallback.get_uint(k, _default); }
void updt_params(params_ref const & p) { m_max_memory = megabytes_to_bytes(p.get_uint(":max-memory", UINT_MAX)); m_produce_models = p.get_bool(":produce-models", false); }
void updt_params_core(params_ref const & p) { m_blast_quant = p.get_bool("blast_quant", false); }