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