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);
}
