void project_plugin::partition_args(model& model, app_ref_vector const& selects, expr_ref_vector& lits) {
ast_manager& m = selects.get_manager();
if (selects.empty()) return;
unsigned num_args = selects[0]->get_decl()->get_arity();
for (unsigned j = 1; j < num_args; ++j) {
expr_ref_vector args(m);
for (unsigned i = 0; i < selects.size(); ++i) {
args.push_back(selects[i]->get_arg(j));
}
project_plugin::partition_values(model, args, lits);
}
}
static void parse_fml(char const* str, app_ref_vector& vars, expr_ref& fml) {
ast_manager& m = fml.get_manager();
fml = parse_fml(m, str);
if (is_exists(fml)) {
quantifier* q = to_quantifier(fml);
for (unsigned i = 0; i < q->get_num_decls(); ++i) {
vars.push_back(m.mk_const(q->get_decl_name(i), q->get_decl_sort(i)));
}
fml = q->get_expr();
var_subst vs(m, true);
vs(fml, vars.size(), (expr*const*)vars.c_ptr(), fml);
}
}
static expr_ref_vector mk_ineqs(app* x, app* y, app_ref_vector const& nums) {
ast_manager& m = nums.get_manager();
arith_util a(m);
expr_ref_vector result(m);
for (unsigned i = 0; i < nums.size(); ++i) {
expr_ref ax(a.mk_mul(nums[i], x), m);
result.push_back(a.mk_le(ax, y));
result.push_back(m.mk_not(a.mk_ge(ax, y)));
result.push_back(m.mk_not(a.mk_gt(y, ax)));
result.push_back(a.mk_lt(y, ax));
}
return result;
}
void euf_arith_mbi_plugin::filter_private_arith(app_ref_vector& avars) {
arith_util a(m);
unsigned j = 0;
obj_hashtable<func_decl> shared;
for (func_decl* f : m_shared) shared.insert(f);
for (unsigned i = 0; i < avars.size(); ++i) {
app* v = avars.get(i);
if (!shared.contains(v->get_decl()) &&
v->get_family_id() != a.get_family_id()) {
avars[j++] = v;
}
}
avars.shrink(j);
}
static bool to_apps(unsigned n, Z3_app const es[], app_ref_vector& result) {
for (unsigned i = 0; i < n; ++i) {
if (!is_app(to_app(es[i]))) {
return false;
}
result.push_back (to_app (es [i]));
}
return true;
}
void filter_variables(model& model, app_ref_vector& vars, expr_ref_vector& lits, expr_ref_vector& unused_lits) {
expr_mark lit_visited;
project_plugin::mark_rec(lit_visited, lits);
unsigned j = 0;
for (unsigned i = 0; i < vars.size(); ++i) {
app* var = vars[i].get();
if (lit_visited.is_marked(var)) {
if (i != j) {
vars[j] = vars[i].get();
}
++j;
}
}
if (vars.size() != j) {
vars.resize(j);
}
}
bool solve(model& model, app_ref_vector& vars, expr_ref_vector& lits) {
expr_mark is_var, is_rem;
if (vars.empty()) {
return false;
}
bool reduced = false;
for (unsigned i = 0; i < vars.size(); ++i) {
is_var.mark(vars[i].get());
}
expr_ref tmp(m), t(m), v(m);
th_rewriter rw(m);
for (unsigned i = 0; i < lits.size(); ++i) {
expr* e = lits[i].get(), *l, *r;
if (m.is_eq(e, l, r) && reduce_eq(is_var, l, r, v, t)) {
reduced = true;
project_plugin::erase(lits, i);
expr_safe_replace sub(m);
sub.insert(v, t);
is_rem.mark(v);
for (unsigned j = 0; j < lits.size(); ++j) {
sub(lits[j].get(), tmp);
rw(tmp);
lits[j] = tmp;
}
}
}
if (reduced) {
unsigned j = 0;
for (unsigned i = 0; i < vars.size(); ++i) {
if (!is_rem.is_marked(vars[i].get())) {
if (i != j) {
vars[j] = vars[i].get();
}
++j;
}
}
vars.shrink(j);
}
return reduced;
}
void rule_manager::mk_negations(app_ref_vector& body, svector<bool>& is_negated) {
for (unsigned i = 0; i < body.size(); ++i) {
expr* e = body[i].get(), *e1;
if (m.is_not(e, e1) && m_ctx.is_predicate(e1)) {
check_app(e1);
body[i] = to_app(e1);
is_negated.push_back(true);
}
else {
is_negated.push_back(false);
}
}
}
is_arith_var_proc(app_ref_vector& avars, app_ref_vector& proxies):
m(avars.m()), m_avars(avars), m_proxies(proxies), m_arith(m) {
}
