Z3_tactic Z3_API Z3_tactic_or_else(Z3_context c, Z3_tactic t1, Z3_tactic t2) {
Z3_TRY;
LOG_Z3_tactic_or_else(c, t1, t2);
RESET_ERROR_CODE();
tactic * new_t = or_else(to_tactic_ref(t1), to_tactic_ref(t2));
RETURN_TACTIC(new_t);
Z3_CATCH_RETURN(0);
}
static tactic * mk_bounded_tactic(ast_manager & m) {
return and_then(fail_if(mk_is_unbounded_probe()),
or_else(try_for(mk_no_cut_smt_tactic(100), 5000),
try_for(mk_no_cut_no_relevancy_smt_tactic(200), 5000),
try_for(mk_no_cut_smt_tactic(300), 15000)
),
mk_fail_if_undecided_tactic());
}
tactic * mk_qfnia_tactic(ast_manager & m, params_ref const & p) {
return and_then(mk_qfnia_premable(m, p),
or_else(mk_qfnia_sat_solver(m, p),
try_for(mk_qfnia_smt_solver(m, p), 2000),
mk_qfnia_nlsat_solver(m, p),
mk_qfnia_smt_solver(m, p)));
}
tactic * mk_qflia_tactic(ast_manager & m, params_ref const & p) {
params_ref main_p;
main_p.set_bool("elim_and", true);
main_p.set_bool("som", true);
main_p.set_bool("blast_distinct", true);
main_p.set_uint("blast_distinct_threshold", 128);
// main_p.set_bool("push_ite_arith", true);
params_ref pull_ite_p;
pull_ite_p.set_bool("pull_cheap_ite", true);
pull_ite_p.set_bool("push_ite_arith", false);
pull_ite_p.set_bool("local_ctx", true);
pull_ite_p.set_uint("local_ctx_limit", 10000000);
params_ref ctx_simp_p;
ctx_simp_p.set_uint("max_depth", 30);
ctx_simp_p.set_uint("max_steps", 5000000);
params_ref lhs_p;
lhs_p.set_bool("arith_lhs", true);
tactic * preamble_st = and_then(and_then(mk_simplify_tactic(m),
mk_propagate_values_tactic(m),
using_params(mk_ctx_simplify_tactic(m), ctx_simp_p),
using_params(mk_simplify_tactic(m), pull_ite_p)),
mk_solve_eqs_tactic(m),
mk_elim_uncnstr_tactic(m),
using_params(mk_simplify_tactic(m), lhs_p)
);
params_ref quasi_pb_p;
quasi_pb_p.set_uint("lia2pb_max_bits", 64);
params_ref no_cut_p;
no_cut_p.set_uint("arith.branch_cut_ratio", 10000000);
tactic * st = using_params(and_then(preamble_st,
or_else(mk_ilp_model_finder_tactic(m),
mk_pb_tactic(m),
and_then(fail_if_not(mk_quasi_pb_probe()),
using_params(mk_lia2sat_tactic(m), quasi_pb_p),
mk_fail_if_undecided_tactic()),
mk_bounded_tactic(m),
mk_smt_tactic())),
main_p);
st->updt_params(p);
return st;
}
tactic * mk_qflia_tactic(ast_manager & m, params_ref const & p) {
params_ref main_p;
main_p.set_bool(":elim-and", true);
main_p.set_bool(":som", true);
// main_p.set_bool(":push-ite-arith", true);
params_ref pull_ite_p;
pull_ite_p.set_bool(":pull-cheap-ite", true);
pull_ite_p.set_bool(":push-ite-arith", false);
pull_ite_p.set_bool(":local-ctx", true);
pull_ite_p.set_uint(":local-ctx-limit", 10000000);
params_ref ctx_simp_p;
ctx_simp_p.set_uint(":max-depth", 30);
ctx_simp_p.set_uint(":max-steps", 5000000);
params_ref lhs_p;
lhs_p.set_bool(":arith-lhs", true);
tactic * preamble_st = and_then(and_then(mk_simplify_tactic(m),
mk_propagate_values_tactic(m),
using_params(mk_ctx_simplify_tactic(m), ctx_simp_p),
using_params(mk_simplify_tactic(m), pull_ite_p)),
mk_solve_eqs_tactic(m),
mk_elim_uncnstr_tactic(m),
using_params(mk_simplify_tactic(m), lhs_p)
);
params_ref quasi_pb_p;
quasi_pb_p.set_uint(":lia2pb-max-bits", 64);
params_ref no_cut_p;
no_cut_p.set_uint(":arith-branch-cut-ratio", 10000000);
tactic * st = using_params(and_then(preamble_st,
or_else(mk_ilp_model_finder_tactic(m),
mk_pb_tactic(m),
and_then(fail_if_not(mk_quasi_pb_probe()),
using_params(mk_lia2sat_tactic(m), quasi_pb_p),
mk_fail_if_undecided_tactic()),
mk_bounded_tactic(m),
mk_smt_tactic())),
main_p);
st->updt_params(p);
return st;
}
static tactic * mk_pb_tactic(ast_manager & m) {
params_ref pb2bv_p;
pb2bv_p.set_bool("ite_extra", true);
pb2bv_p.set_uint("pb2bv_all_clauses_limit", 8);
return and_then(fail_if_not(mk_is_pb_probe()),
fail_if(mk_produce_proofs_probe()),
fail_if(mk_produce_unsat_cores_probe()),
or_else(and_then(fail_if(mk_ge(mk_num_exprs_probe(), mk_const_probe(SMALL_SIZE))),
fail_if_not(mk_is_ilp_probe()),
// try_for(mk_mip_tactic(m), 8000),
mk_fail_if_undecided_tactic()),
and_then(using_params(mk_pb2bv_tactic(m), pb2bv_p),
fail_if_not(mk_is_qfbv_probe()),
mk_bv2sat_tactic(m))));
}
tactic * mk_qfnra_tactic(ast_manager & m, params_ref const& p) {
params_ref p1 = p;
p1.set_uint("seed", 11);
p1.set_bool("factor", false);
params_ref p2 = p;
p2.set_uint("seed", 13);
p2.set_bool("factor", false);
return and_then(mk_simplify_tactic(m, p),
mk_propagate_values_tactic(m, p),
or_else(try_for(mk_qfnra_nlsat_tactic(m, p), 5000),
try_for(mk_qfnra_nlsat_tactic(m, p1), 10000),
mk_qfnra_sat_solver(m, p, 4),
and_then(try_for(mk_smt_tactic(), 5000), mk_fail_if_undecided_tactic()),
mk_qfnra_sat_solver(m, p, 6),
mk_qfnra_nlsat_tactic(m, p2)));
}
tactic * mk_nra_tactic(ast_manager & m, params_ref const& p) {
params_ref p1 = p;
p1.set_uint("seed", 11);
p1.set_bool("factor", false);
params_ref p2 = p;
p2.set_uint("seed", 13);
p2.set_bool("factor", false);
return and_then(mk_simplify_tactic(m, p),
mk_nnf_tactic(m, p),
mk_propagate_values_tactic(m, p),
mk_qe_tactic(m, p),
cond(mk_is_qfnra_probe(),
or_else(try_for(mk_qfnra_nlsat_tactic(m, p), 5000),
try_for(mk_qfnra_nlsat_tactic(m, p1), 10000),
mk_qfnra_nlsat_tactic(m, p2)),
mk_smt_tactic(p)));
}
// Try to find a model for an unbounded ILP problem.
// Fails if the problem is no ILP.
static tactic * mk_ilp_model_finder_tactic(ast_manager & m) {
params_ref add_bounds_p1;
add_bounds_p1.set_rat(":add-bound-lower", rational(-16));
add_bounds_p1.set_rat(":add-bound-upper", rational(15));
params_ref add_bounds_p2;
add_bounds_p2.set_rat(":add-bound-lower", rational(-32));
add_bounds_p2.set_rat(":add-bound-upper", rational(31));
return and_then(fail_if_not(mk_and(mk_is_ilp_probe(), mk_is_unbounded_probe())),
fail_if(mk_produce_proofs_probe()),
fail_if(mk_produce_unsat_cores_probe()),
mk_propagate_ineqs_tactic(m),
or_else(try_for(mk_mip_tactic(m), 5000),
try_for(mk_no_cut_smt_tactic(100), 2000),
and_then(using_params(mk_add_bounds_tactic(m), add_bounds_p1),
try_for(mk_lia2sat_tactic(m), 5000)),
try_for(mk_no_cut_smt_tactic(200), 5000),
and_then(using_params(mk_add_bounds_tactic(m), add_bounds_p2),
try_for(mk_lia2sat_tactic(m), 10000)),
mk_mip_tactic(m)),
mk_fail_if_undecided_tactic());
}
}
tactic * mk_uflra_tactic(ast_manager & m, params_ref const & p) {
tactic * st = and_then(mk_quant_preprocessor(m),
mk_smt_tactic());
st->updt_params(p);
return st;
}
tactic * mk_auflia_tactic(ast_manager & m, params_ref const & p) {
params_ref qi_p;
qi_p.set_str("qi.cost", "0");
TRACE("qi_cost", qi_p.display(tout); tout << "\n" << qi_p.get_str("qi.cost", "<null>") << "\n";);
tactic * st = and_then(mk_no_solve_eq_preprocessor(m),
or_else(and_then(fail_if(mk_gt(mk_num_exprs_probe(), mk_const_probe(static_cast<double>(128)))),
using_params(mk_smt_tactic(), qi_p),
mk_fail_if_undecided_tactic()),
mk_smt_tactic()));
st->updt_params(p);
return st;
}
tactic * mk_auflira_tactic(ast_manager & m, params_ref const & p) {
tactic * st = and_then(mk_quant_preprocessor(m),
mk_smt_tactic());
st->updt_params(p);
return st;
}
tactic * mk_aufnira_tactic(ast_manager & m, params_ref const & p) {
tactic * st = and_then(mk_quant_preprocessor(m),
mk_smt_tactic());
tactic * mk_qfidl_tactic(ast_manager & m, params_ref const & p) {
params_ref main_p;
main_p.set_bool("elim_and", true);
main_p.set_bool("blast_distinct", true);
main_p.set_bool("som", true);
params_ref lhs_p;
lhs_p.set_bool("arith_lhs", true);
params_ref lia2pb_p;
lia2pb_p.set_uint("lia2pb_max_bits", 4);
params_ref pb2bv_p;
pb2bv_p.set_uint("pb2bv_all_clauses_limit", 8);
params_ref pull_ite_p;
pull_ite_p.set_bool("pull_cheap_ite", true);
pull_ite_p.set_bool("local_ctx", true);
pull_ite_p.set_uint("local_ctx_limit", 10000000);
tactic * preamble_st = and_then(and_then(mk_simplify_tactic(m),
mk_fix_dl_var_tactic(m),
mk_propagate_values_tactic(m),
mk_elim_uncnstr_tactic(m)
),
and_then(mk_solve_eqs_tactic(m),
using_params(mk_simplify_tactic(m), lhs_p),
mk_propagate_values_tactic(m),
mk_normalize_bounds_tactic(m),
mk_solve_eqs_tactic(m)));
params_ref bv_solver_p;
// The cardinality constraint encoding generates a lot of shared if-then-else's that can be flattened.
// Several of them are simplified to and/or. If we flat them, we increase a lot the memory consumption.
bv_solver_p.set_bool("flat", false);
bv_solver_p.set_bool("som", false);
// dynamic psm seems to work well.
bv_solver_p.set_sym("gc", symbol("dyn_psm"));
tactic * bv_solver = using_params(and_then(mk_simplify_tactic(m),
mk_propagate_values_tactic(m),
mk_solve_eqs_tactic(m),
mk_max_bv_sharing_tactic(m),
mk_bit_blaster_tactic(m),
mk_aig_tactic(),
mk_sat_tactic(m)),
bv_solver_p);
tactic * try2bv =
and_then(using_params(mk_lia2pb_tactic(m), lia2pb_p),
mk_propagate_ineqs_tactic(m),
using_params(mk_pb2bv_tactic(m), pb2bv_p),
fail_if(mk_not(mk_is_qfbv_probe())),
bv_solver);
params_ref diff_neq_p;
diff_neq_p.set_uint("diff_neq_max_k", 25);
tactic * st = cond(mk_and(mk_lt(mk_num_consts_probe(), mk_const_probe(static_cast<double>(BIG_PROBLEM))),
mk_and(mk_not(mk_produce_proofs_probe()),
mk_not(mk_produce_unsat_cores_probe()))),
using_params(and_then(preamble_st,
or_else(using_params(mk_diff_neq_tactic(m), diff_neq_p),
try2bv,
mk_smt_tactic())),
main_p),
mk_smt_tactic());
st->updt_params(p);
return st;
}