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