mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-08-14 06:45:25 +00:00
Code Activity

bool_vector, some spacer tidy

Browse source 
Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com>
This commit is contained in:
Nikolaj Bjorner 2020-04-05 12:59:04 -07:00
parent 2ed26e8e73
commit b889b110ee
106 changed files with 239 additions and 266 deletions
Download patch file Download diff file Expand all files Collapse all files

8
src/muz/base/dl_rule.cpp
View file

@ -153,7 +153,7 @@ namespace datalog {
mk_rule_core(fml1, pr, rules, name);
}
void rule_manager::mk_negations(app_ref_vector& body, svector<bool>& is_negated) {
void rule_manager::mk_negations(app_ref_vector& body, bool_vector& 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)) {
@ -628,7 +628,7 @@ namespace datalog {
}
if (change) {
app_ref_vector tail(m);
svector<bool> tail_neg;
bool_vector tail_neg;
for (unsigned i = 0; i < ut_len; ++i) {
tail.push_back(r->get_tail(i));
tail_neg.push_back(r->is_neg_tail(i));
@ -660,7 +660,7 @@ namespace datalog {
var_counter vctr;
app_ref_vector tail(m);
svector<bool> tail_neg;
bool_vector tail_neg;
app_ref head(r->get_head(), m);
vctr.count_vars(head);
@ -811,7 +811,7 @@ namespace datalog {
expr_ref tmp(m);
app_ref new_head(m);
app_ref_vector new_tail(m);
svector<bool> tail_neg;
bool_vector tail_neg;
var_subst vs(m, false);
tmp = vs(r->get_head(), sz, es);
new_head = to_app(tmp);

4
src/muz/base/dl_rule.h
View file

@ -124,7 +124,7 @@ namespace datalog {
app_ref_vector m_body;
app_ref m_head;
expr_ref_vector m_args;
svector<bool> m_neg;
bool_vector m_neg;
hnf m_hnf;
qe_lite m_qe;
label_rewriter m_rwr;
@ -158,7 +158,7 @@ namespace datalog {
void bind_variables(expr* fml, bool is_forall, expr_ref& result);
void mk_negations(app_ref_vector& body, svector<bool>& is_negated);
void mk_negations(app_ref_vector& body, bool_vector& is_negated);
void mk_rule_core(expr* fml, proof* p, rule_set& rules, symbol const& name);

2
src/muz/base/dl_rule_transformer.cpp
View file

@ -132,7 +132,7 @@ namespace datalog {
//
//------------------------------
void rule_transformer::plugin::remove_duplicate_tails(app_ref_vector& tail, svector<bool>& tail_neg)
void rule_transformer::plugin::remove_duplicate_tails(app_ref_vector& tail, bool_vector& tail_neg)
{
//one set for positive and one for negative
obj_hashtable<app> tail_apps[2];

2
src/muz/base/dl_rule_transformer.h
View file

@ -108,7 +108,7 @@ namespace datalog {
/**
Removes duplicate tails.
*/
static void remove_duplicate_tails(app_ref_vector& tail, svector<bool>& tail_neg);
static void remove_duplicate_tails(app_ref_vector& tail, bool_vector& tail_neg);
};
};

4
src/muz/ddnf/ddnf.cpp
View file

@ -135,7 +135,7 @@ namespace datalog {
ddnf_node::hash m_hash;
ddnf_node::eq m_eq;
ddnf_nodes m_nodes;
svector<bool> m_marked;
bool_vector m_marked;
stats m_stats;
public:
ddnf_mgr(unsigned n): m_noderefs(*this), m_internalized(false), m_tbv(n),
@ -338,7 +338,7 @@ namespace datalog {
}
ptr_vector<ddnf_node> todo;
todo.push_back(m_root);
svector<bool> done(m_noderefs.size(), false);
bool_vector done(m_noderefs.size(), false);
while (!todo.empty()) {
ddnf_node& n = *todo.back();
if (done[n.get_id()]) {

2
src/muz/fp/datalog_parser.cpp
View file

@ -724,7 +724,7 @@ protected:
dtoken parse_body(app* head) {
app_ref_vector body(m_manager);
svector<bool> polarity_vect;
bool_vector polarity_vect;
dtoken tok = m_lexer->next_token();
while (tok != TK_ERROR && tok != TK_EOS) {
if (tok == TK_PERIOD) {

2
src/muz/rel/dl_base.h
View file

@ -582,7 +582,7 @@ namespace datalog {
const unsigned_vector m_cols2;
bool m_all_neg_bound; //all columns are bound at least once
bool m_overlap; //one column in negated table is bound multiple times
svector<bool> m_bound;
bool_vector m_bound;
convenient_negation_filter_fn(const base_object & tgt, const base_object & neg_t,
unsigned joined_col_cnt, const unsigned * t_cols, const unsigned * negated_cols)

20
src/muz/rel/dl_finite_product_relation.cpp
View file

@ -92,12 +92,12 @@ namespace datalog {
family_id finite_product_relation_plugin::get_relation_kind(finite_product_relation & r,
const bool * table_columns) {
const relation_signature & sig = r.get_signature();
svector<bool> table_cols_vect(sig.size(), table_columns);
bool_vector table_cols_vect(sig.size(), table_columns);
return m_spec_store.get_relation_kind(sig, rel_spec(table_cols_vect));
}
void finite_product_relation_plugin::get_all_possible_table_columns(relation_manager & rmgr,
const relation_signature & s, svector<bool> & table_columns) {
const relation_signature & s, bool_vector & table_columns) {
SASSERT(table_columns.empty());
unsigned s_sz = s.size();
for(unsigned i=0; i<s_sz; i++) {
@ -148,7 +148,7 @@ namespace datalog {
}
relation_base * finite_product_relation_plugin::mk_empty(const relation_signature & s) {
svector<bool> table_columns;
bool_vector table_columns;
get_all_possible_table_columns(s, table_columns);
#ifndef _EXTERNAL_RELEASE
unsigned s_sz = s.size();
@ -275,7 +275,7 @@ namespace datalog {
SASSERT(join_fun);
scoped_rel<table_base> res_table = (*join_fun)(t, *idx_singleton);
svector<bool> table_cols(sig.size(), true);
bool_vector table_cols(sig.size(), true);
finite_product_relation * res = mk_empty(sig, table_cols.c_ptr());
//this one does not need to be deleted -- it will be taken over by \c res in the \c init function
@ -301,7 +301,7 @@ namespace datalog {
idx_singleton_fact.push_back(0);
idx_singleton->add_fact(idx_singleton_fact);
svector<bool> table_cols(sig.size(), false);
bool_vector table_cols(sig.size(), false);
finite_product_relation * res = mk_empty(sig, table_cols.c_ptr());
relation_vector rels;
@ -378,7 +378,7 @@ namespace datalog {
scoped_ptr<table_transformer_fn> m_tjoined_second_rel_remover;
//determines which columns of the result are table columns and which are in the inner relation
svector<bool> m_res_table_columns;
bool_vector m_res_table_columns;
public:
class join_maker : public table_row_mutator_fn {
@ -529,7 +529,7 @@ namespace datalog {
scoped_ptr<relation_union_fn> m_inner_rel_union;
//determines which columns of the result are table columns and which are in the inner relation
svector<bool> m_res_table_columns;
bool_vector m_res_table_columns;
public:
project_fn(const finite_product_relation & r, unsigned col_cnt, const unsigned * removed_cols)
: convenient_relation_project_fn(r.get_signature(), col_cnt, removed_cols) {
@ -665,7 +665,7 @@ namespace datalog {
unsigned_vector m_rel_permutation;
//determines which columns of the result are table columns and which are in the inner relation
svector<bool> m_res_table_columns;
bool_vector m_res_table_columns;
public:
rename_fn(const finite_product_relation & r, unsigned cycle_len, const unsigned * permutation_cycle)
: convenient_relation_rename_fn(r.get_signature(), cycle_len, permutation_cycle) {
@ -2156,7 +2156,7 @@ namespace datalog {
return true;
}
unsigned sig_sz = rels.back()->get_signature().size();
svector<bool> table_cols(sig_sz, true);
bool_vector table_cols(sig_sz, true);
ptr_vector<finite_product_relation>::iterator it = rels.begin();
ptr_vector<finite_product_relation>::iterator end = rels.end();
@ -2221,7 +2221,7 @@ namespace datalog {
scoped_rel<relation_base> moved_cols_trel =
rmgr.get_table_relation_plugin(moved_cols_table->get_plugin()).mk_from_table(moved_cols_sig, moved_cols_table);
svector<bool> moved_cols_table_flags(moved_cols_sig.size(), false);
bool_vector moved_cols_table_flags(moved_cols_sig.size(), false);
scoped_rel<finite_product_relation> moved_cols_rel = get_plugin().mk_empty(moved_cols_sig,
moved_cols_table_flags.c_ptr());

8
src/muz/rel/dl_finite_product_relation.h
View file

@ -36,10 +36,10 @@ namespace datalog {
public:
struct rel_spec {
family_id m_inner_kind; //null_family_id means we don't care about the kind
svector<bool> m_table_cols;
bool_vector m_table_cols;
rel_spec() : m_inner_kind(null_family_id) {}
rel_spec(const svector<bool>& table_cols)
rel_spec(const bool_vector& table_cols)
: m_inner_kind(null_family_id), m_table_cols(table_cols) {}
bool operator==(const rel_spec & o) const {
@ -74,8 +74,8 @@ namespace datalog {
family_id get_relation_kind(finite_product_relation & r, const bool * table_columns);
static void get_all_possible_table_columns(relation_manager & rmgr, const relation_signature & s,
svector<bool> & table_columns);
void get_all_possible_table_columns(const relation_signature & s, svector<bool> & table_columns) {
bool_vector & table_columns);
void get_all_possible_table_columns(const relation_signature & s, bool_vector & table_columns) {
get_all_possible_table_columns(get_manager(), s, table_columns);
}

6
src/muz/rel/dl_mk_explanations.cpp
View file

@ -644,10 +644,10 @@ namespace datalog {
relation_signature sig;
rmgr.from_predicate(e_decl, sig);
svector<bool> inner_sieve(sz-1, true);
bool_vector inner_sieve(sz-1, true);
inner_sieve.push_back(false);
svector<bool> expl_sieve(sz-1, false);
bool_vector expl_sieve(sz-1, false);
expl_sieve.push_back(true);
sieve_relation_plugin & sieve_plugin = sieve_relation_plugin::get_plugin(rmgr);
@ -715,7 +715,7 @@ namespace datalog {
app_ref e_head(get_e_lit(r->get_head(), head_var), m_manager);
app_ref_vector e_tail(m_manager);
svector<bool> neg_flags;
bool_vector neg_flags;
unsigned pos_tail_sz = r->get_positive_tail_size();
for (unsigned i=0; i<pos_tail_sz; i++) {
unsigned e_var = next_var++;

2
src/muz/rel/dl_mk_similarity_compressor.cpp
View file

@ -373,7 +373,7 @@ namespace datalog {
app * new_head = r->get_head();
ptr_vector<app> new_tail;
svector<bool> new_negs;
bool_vector new_negs;
unsigned tail_sz = r->get_tail_size();
for (unsigned i=0; i<tail_sz; i++) {
new_tail.push_back(r->get_tail(i));

2
src/muz/rel/dl_mk_simple_joins.cpp
View file

@ -711,7 +711,7 @@ namespace datalog {
}
ptr_vector<app> tail(content);
svector<bool> negs(tail.size(), false);
bool_vector negs(tail.size(), false);
unsigned or_len = orig_r->get_tail_size();
for (unsigned i=orig_r->get_positive_tail_size(); i < or_len; i++) {
tail.push_back(orig_r->get_tail(i));

22
src/muz/rel/dl_sieve_relation.cpp
View file

@ -149,7 +149,7 @@ namespace datalog {
}
void sieve_relation_plugin::extract_inner_columns(const relation_signature & s, relation_plugin & inner,
svector<bool> & inner_columns) {
bool_vector & inner_columns) {
SASSERT(inner_columns.size()==s.size());
unsigned n = s.size();
relation_signature inner_sig_singleton;
@ -168,7 +168,7 @@ namespace datalog {
}
void sieve_relation_plugin::collect_inner_signature(const relation_signature & s,
const svector<bool> & inner_columns, relation_signature & inner_sig) {
const bool_vector & inner_columns, relation_signature & inner_sig) {
SASSERT(inner_columns.size()==s.size());
inner_sig.reset();
unsigned n = s.size();
@ -183,7 +183,7 @@ namespace datalog {
relation_signature & inner_sig) {
UNREACHABLE();
#if 0
svector<bool> inner_cols(s.size());
bool_vector inner_cols(s.size());
extract_inner_columns(s, inner_cols.c_ptr());
collect_inner_signature(s, inner_cols, inner_sig);
#endif
@ -228,7 +228,7 @@ namespace datalog {
UNREACHABLE();
return nullptr;
#if 0
svector<bool> inner_cols(s.size());
bool_vector inner_cols(s.size());
extract_inner_columns(s, inner_cols.c_ptr());
return mk_empty(s, inner_cols.c_ptr());
#endif
@ -236,7 +236,7 @@ namespace datalog {
sieve_relation * sieve_relation_plugin::mk_empty(const relation_signature & s, relation_plugin & inner_plugin) {
SASSERT(!inner_plugin.is_sieve_relation()); //it does not make sense to make a sieve of a sieve
svector<bool> inner_cols(s.size());
bool_vector inner_cols(s.size());
extract_inner_columns(s, inner_plugin, inner_cols);
relation_signature inner_sig;
collect_inner_signature(s, inner_cols, inner_sig);
@ -248,14 +248,14 @@ namespace datalog {
relation_signature empty_sig;
relation_plugin& plugin = get_manager().get_appropriate_plugin(s);
relation_base * inner = plugin.mk_full(p, empty_sig, null_family_id);
svector<bool> inner_cols;
bool_vector inner_cols;
inner_cols.resize(s.size(), false);
return mk_from_inner(s, inner_cols, inner);
}
sieve_relation * sieve_relation_plugin::full(func_decl* p, const relation_signature & s, relation_plugin & inner_plugin) {
SASSERT(!inner_plugin.is_sieve_relation()); //it does not make sense to make a sieve of a sieve
svector<bool> inner_cols(s.size());
bool_vector inner_cols(s.size());
extract_inner_columns(s, inner_plugin, inner_cols);
relation_signature inner_sig;
collect_inner_signature(s, inner_cols, inner_sig);
@ -267,7 +267,7 @@ namespace datalog {
sieve_relation_plugin & m_plugin;
unsigned_vector m_inner_cols_1;
unsigned_vector m_inner_cols_2;
svector<bool> m_result_inner_cols;
bool_vector m_result_inner_cols;
scoped_ptr<relation_join_fn> m_inner_join_fun;
public:
@ -347,7 +347,7 @@ namespace datalog {
class sieve_relation_plugin::transformer_fn : public convenient_relation_transformer_fn {
svector<bool> m_result_inner_cols;
bool_vector m_result_inner_cols;
scoped_ptr<relation_transformer_fn> m_inner_fun;
public:
@ -383,7 +383,7 @@ namespace datalog {
}
}
svector<bool> result_inner_cols = r.m_inner_cols;
bool_vector result_inner_cols = r.m_inner_cols;
project_out_vector_columns(result_inner_cols, col_cnt, removed_cols);
relation_signature result_sig;
@ -419,7 +419,7 @@ namespace datalog {
unsigned_vector inner_permutation;
collect_sub_permutation(permutation, r.m_sig2inner, inner_permutation, inner_identity);
svector<bool> result_inner_cols = r.m_inner_cols;
bool_vector result_inner_cols = r.m_inner_cols;
permutate_by_cycle(result_inner_cols, cycle_len, permutation_cycle);
relation_signature result_sig;

12
src/muz/rel/dl_sieve_relation.h
View file

@ -31,7 +31,7 @@ namespace datalog {
friend class sieve_relation;
public:
struct rel_spec {
svector<bool> m_inner_cols;
bool_vector m_inner_cols;
family_id m_inner_kind;
/**
@ -70,9 +70,9 @@ namespace datalog {
family_id get_relation_kind(sieve_relation & r, const bool * inner_columns);
void extract_inner_columns(const relation_signature & s, relation_plugin & inner,
svector<bool> & inner_columns);
bool_vector & inner_columns);
void extract_inner_signature(const relation_signature & s, relation_signature & inner_sig);
void collect_inner_signature(const relation_signature & s, const svector<bool> & inner_columns,
void collect_inner_signature(const relation_signature & s, const bool_vector & inner_columns,
relation_signature & inner_sig);
public:
static symbol get_name() { return symbol("sieve_relation"); }
@ -89,7 +89,7 @@ namespace datalog {
family_id get_relation_kind(const relation_signature & sig, const bool * inner_columns,
family_id inner_kind);
family_id get_relation_kind(const relation_signature & sig, const svector<bool> & inner_columns,
family_id get_relation_kind(const relation_signature & sig, const bool_vector & inner_columns,
family_id inner_kind) {
SASSERT(sig.size()==inner_columns.size());
return get_relation_kind(sig, inner_columns.c_ptr(), inner_kind);
@ -108,7 +108,7 @@ namespace datalog {
sieve_relation * mk_from_inner(const relation_signature & s, const bool * inner_columns,
relation_base * inner_rel);
sieve_relation * mk_from_inner(const relation_signature & s, const svector<bool> & inner_columns,
sieve_relation * mk_from_inner(const relation_signature & s, const bool_vector & inner_columns,
relation_base * inner_rel) {
SASSERT(inner_columns.size()==s.size());
return mk_from_inner(s, inner_columns.c_ptr(), inner_rel);
@ -148,7 +148,7 @@ namespace datalog {
friend class sieve_relation_plugin::union_fn;
friend class sieve_relation_plugin::filter_fn;
svector<bool> m_inner_cols;
bool_vector m_inner_cols;
unsigned_vector m_sig2inner;
unsigned_vector m_inner2sig;

2
src/muz/rel/udoc_relation.cpp
View file

@ -1112,7 +1112,7 @@ namespace datalog {
SASSERT(joined_col_cnt > 0 || neg.get_signature().size() == 0);
m_is_subtract = (joined_col_cnt == t.get_signature().size());
m_is_subtract &= (joined_col_cnt == neg.get_signature().size());
svector<bool> found(joined_col_cnt, false);
bool_vector found(joined_col_cnt, false);
for (unsigned i = 0; m_is_subtract && i < joined_col_cnt; ++i) {
m_is_subtract = !found[t_cols[i]] && (t_cols[i] == neg_cols[i]);
found[t_cols[i]] = true;

100
src/muz/spacer/spacer_context.cpp
View file

@ -239,9 +239,8 @@ void derivation::exist_skolemize(expr* fml, app_ref_vector &vars, expr_ref &res)
vars.shrink(j);
}
TRACE("spacer", tout << "Skolemizing: ";
for (auto v : vars) tout << " " << mk_pp(v, m) << " ";
tout << "\nfrom " << mk_pp(fml, m) << "\n";
TRACE("spacer", tout << "Skolemizing: " << vars << "\n";
tout << "from " << mk_pp(fml, m) << "\n";
);
app_ref_vector pinned(m);
@ -868,7 +867,7 @@ const datalog::rule *pred_transformer::find_rule(model &model) {
const datalog::rule *pred_transformer::find_rule(model &model,
bool& is_concrete,
vector<bool>& reach_pred_used,
bool_vector& reach_pred_used,
unsigned& num_reuse_reach)
{
// find a rule whose tag is true in the model;
@ -1188,14 +1187,13 @@ expr_ref pred_transformer::get_origin_summary (model &mdl,
// (skip quantified lemmas cause we can't validate them in the model)
// TBD: for quantified lemmas use current instances
flatten_and(summary);
for (auto *s : summary) {
for (auto* s : summary) {
if (!is_quantifier(s) && !mdl.is_true(s)) {
TRACE("spacer", tout << "Summary not true in the model: "
<< mk_pp(s, m) << "\n";);
// return expr_ref(m);
TRACE("spacer", tout << "Summary not true in the model: " << mk_pp(s, m) << "\n";);
}
}
// -- pick an implicant
expr_ref_vector lits(m);
compute_implicant_literals (mdl, summary, lits);
@ -1209,12 +1207,10 @@ void pred_transformer::add_cover(unsigned level, expr* property, bool bg)
// replace bound variables by local constants.
expr_ref result(property, m), v(m), c(m);
expr_substitution sub(m);
proof_ref pr(m);
pr = m.mk_asserted(m.mk_true());
for (unsigned i = 0; i < sig_size(); ++i) {
c = m.mk_const(pm.o2n(sig(i), 0));
v = m.mk_var(i, sig(i)->get_range());
sub.insert(v, c, pr);
sub.insert(v, c);
}
scoped_ptr<expr_replacer> rep = mk_default_expr_replacer(m, false);
rep->set_substitution(&sub);
@ -1224,13 +1220,14 @@ void pred_transformer::add_cover(unsigned level, expr* property, bool bg)
// add the property.
expr_ref_vector lemmas(m);
flatten_and(result, lemmas);
for (unsigned i = 0, sz = lemmas.size(); i < sz; ++i) {
add_lemma(lemmas.get(i), level, bg);
for (expr * f: lemmas) {
add_lemma(f, level, bg);
}
}
void pred_transformer::propagate_to_infinity (unsigned level)
{m_frames.propagate_to_infinity (level);}
void pred_transformer::propagate_to_infinity (unsigned level) {
m_frames.propagate_to_infinity (level);
}
// compute a conjunction of all background facts
void pred_transformer::get_pred_bg_invs(expr_ref_vector& out) {
@ -1274,7 +1271,9 @@ bool pred_transformer::is_blocked (pob &n, unsigned &uses_level)
// XXX quic3: not all lemmas are asserted at the post-condition
lbool res = m_solver->check_assumptions (post, _aux, _aux,
0, nullptr, 0);
if (res == l_false) { uses_level = m_solver->uses_level(); }
if (res == l_false) {
uses_level = m_solver->uses_level();
}
return res == l_false;
}
@ -1298,10 +1297,9 @@ bool pred_transformer::is_qblocked (pob &n) {
// assert all lemmas
bool has_quant = false;
for (unsigned i = 0, sz = frame_lemmas.size (); i < sz; ++i)
{
has_quant = has_quant || is_quantifier(frame_lemmas.get(i));
s->assert_expr(frame_lemmas.get(i));
for (expr* f : frame_lemmas) {
has_quant |= is_quantifier(f);
s->assert_expr(f);
}
if (!has_quant) return false;
@ -1335,7 +1333,7 @@ void pred_transformer::mbp(app_ref_vector &vars, expr_ref &fml, model &mdl,
lbool pred_transformer::is_reachable(pob& n, expr_ref_vector* core,
model_ref* model, unsigned& uses_level,
bool& is_concrete, datalog::rule const*& r,
vector<bool>& reach_pred_used,
bool_vector& reach_pred_used,
unsigned& num_reuse_reach)
{
TRACE("spacer",
@ -1388,14 +1386,8 @@ lbool pred_transformer::is_reachable(pob& n, expr_ref_vector* core,
}
}
TRACE ("spacer",
if (!reach_assumps.empty ()) {
tout << "reach assumptions\n";
for (unsigned i = 0; i < reach_assumps.size (); i++) {
tout << mk_pp (reach_assumps.get (i), m) << "\n";
}
}
);
CTRACE("spacer", !reach_assumps.empty(),
tout << "reach assumptions\n" << reach_assumps << "\n";);
// check local reachability;
// result is either sat (with some reach assumps) or
@ -1404,24 +1396,15 @@ lbool pred_transformer::is_reachable(pob& n, expr_ref_vector* core,
lbool is_sat = m_solver->check_assumptions (post, reach_assumps,
m_transition_clause, 1, &bg, 0);
TRACE ("spacer",
if (!reach_assumps.empty ()) {
tout << "reach assumptions used\n";
for (unsigned i = 0; i < reach_assumps.size (); i++) {
tout << mk_pp (reach_assumps.get (i), m) << "\n";
}
}
);
CTRACE("spacer", !reach_assumps.empty(),
tout << "reach assumptions\n" << reach_assumps << "\n";);
if (is_sat == l_true || is_sat == l_undef) {
if (core) { core->reset(); }
if (model && model->get()) {
r = find_rule(**model, is_concrete, reach_pred_used, num_reuse_reach);
TRACE ("spacer", tout << "reachable "
<< "is_concrete " << is_concrete << " rused: ";
for (unsigned i = 0, sz = reach_pred_used.size (); i < sz; ++i)
tout << reach_pred_used [i];
tout << "\n";);
TRACE("spacer",
tout << "reachable " << r << " is_concrete " << is_concrete << " rused: " << reach_pred_used << "\n";);
}
return is_sat;
@ -2924,8 +2907,6 @@ expr_ref context::get_answer()
}
}
expr_ref context::mk_unsat_answer() const
{
expr_ref_vector refs(m);
@ -2935,7 +2916,6 @@ expr_ref context::mk_unsat_answer() const
return ex.to_expr();
}
proof_ref context::get_ground_refutation() const {
if (m_last_result != l_true) {
IF_VERBOSE(0, verbose_stream()
@ -3272,7 +3252,7 @@ bool context::is_reachable(pob &n)
bool is_concrete;
const datalog::rule * r = nullptr;
// denotes which predecessor's (along r) reach facts are used
vector<bool> reach_pred_used;
bool_vector reach_pred_used;
unsigned num_reuse_reach = 0;
unsigned saved = n.level ();
@ -3382,7 +3362,7 @@ lbool context::expand_pob(pob& n, pob_ref_buffer &out)
bool is_concrete;
const datalog::rule * r = nullptr;
// denotes which predecessor's (along r) reach facts are used
vector<bool> reach_pred_used;
bool_vector reach_pred_used;
unsigned num_reuse_reach = 0;
@ -3694,11 +3674,7 @@ reach_fact *pred_transformer::mk_rf(pob& n, model &mdl, const datalog::rule& r)
TRACE ("spacer",
tout << "Reach fact, before QE:\n";
tout << mk_pp (res, m) << "\n";
tout << "Vars:\n";
for (unsigned i = 0; i < vars.size(); ++i) {
tout << mk_pp(vars.get (i), m) << "\n";
}
);
tout << "Vars:\n" << vars << "\n";);
{
timeit _timer1 (is_trace_enabled("spacer_timeit"),
@ -3711,10 +3687,7 @@ reach_fact *pred_transformer::mk_rf(pob& n, model &mdl, const datalog::rule& r)
TRACE ("spacer",
tout << "Reach fact, after QE project:\n";
tout << mk_pp (res, m) << "\n";
tout << "Vars:\n";
for (unsigned i = 0; i < vars.size(); ++i) {
tout << mk_pp(vars.get (i), m) << "\n";
}
tout << "Vars:\n" << vars << "\n";
);
SASSERT (vars.empty ());
@ -3733,7 +3706,7 @@ reach_fact *pred_transformer::mk_rf(pob& n, model &mdl, const datalog::rule& r)
*/
bool context::create_children(pob& n, datalog::rule const& r,
model &mdl,
const vector<bool> &reach_pred_used,
const bool_vector &reach_pred_used,
pob_ref_buffer &out)
{
scoped_watch _w_ (m_create_children_watch);
@ -4075,13 +4048,12 @@ inline bool pob_lt_proc::operator() (const pob *pn1, const pob *pn2) const
if (p1->get_id() != p2->get_id()) { return p1->get_id() < p2->get_id(); }
if (n1.pt().head()->get_id() == n2.pt().head()->get_id()) {
IF_VERBOSE (1,
verbose_stream ()
<< "dup: " << n1.pt ().head ()->get_name ()
<< "(" << n1.level () << ", " << n1.depth () << ") "
<< p1->get_id () << "\n";
IF_VERBOSE(1,
verbose_stream()
<< "dup: " << n1.pt().head()->get_name()
<< "(" << n1.level() << ", " << n1.depth() << ") "
<< p1->get_id() << "\n";);
//<< " p1: " << mk_pp (const_cast<expr*>(p1), m) << "\n"
);
}
// XXX see comment below on identical nodes

6
src/muz/spacer/spacer_context.h
View file

@ -487,7 +487,7 @@ public:
bool is_ctp_blocked(lemma *lem);
const datalog::rule *find_rule(model &mdl);
const datalog::rule *find_rule(model &mev, bool& is_concrete,
vector<bool>& reach_pred_used,
bool_vector& reach_pred_used,
unsigned& num_reuse_reach);
expr* get_transition(datalog::rule const& r) {
pt_rule *p;
@ -530,7 +530,7 @@ public:
lbool is_reachable(pob& n, expr_ref_vector* core, model_ref *model,
unsigned& uses_level, bool& is_concrete,
datalog::rule const*& r,
vector<bool>& reach_pred_used,
bool_vector& reach_pred_used,
unsigned& num_reuse_reach);
bool is_invariant(unsigned level, lemma* lem,
unsigned& solver_level,
@ -1010,7 +1010,7 @@ class context {
lbool expand_pob(pob &n, pob_ref_buffer &out);
bool create_children(pob& n, const datalog::rule &r,
model &mdl,
const vector<bool>& reach_pred_used,
const bool_vector& reach_pred_used,
pob_ref_buffer &out);
/**

4
src/muz/spacer/spacer_qe_project.cpp
View file

@ -211,8 +211,8 @@ namespace spacer_qe {
expr_ref_vector m_terms;
vector<rational> m_coeffs;
vector<rational> m_divs;
svector<bool> m_strict;
svector<bool> m_eq;
bool_vector m_strict;
bool_vector m_eq;
scoped_ptr<contains_app> m_var;
bool is_linear(rational const& mul, expr* t, rational& c, expr_ref_vector& ts) {

2
src/muz/transforms/dl_mk_backwards.cpp
View file

@ -38,7 +38,7 @@ namespace datalog {
rule_ref new_rule(rm);
app_ref_vector tail(m);
app_ref head(m);
svector<bool> neg;
bool_vector neg;
app_ref query(m);
query = m.mk_fresh_const("Q", m.mk_bool_sort());
result->set_output_predicate(query->get_decl());

4
src/muz/transforms/dl_mk_coalesce.cpp
View file

@ -64,7 +64,7 @@ namespace datalog {
expr_ref_vector revsub(m), conjs(m);
rl.get_vars(m, sorts);
revsub.resize(sorts.size());
svector<bool> valid(sorts.size(), true);
bool_vector valid(sorts.size(), true);
for (unsigned i = 0; i < sub.size(); ++i) {
expr* e = sub[i];
sort* s = m.get_sort(e);
@ -116,7 +116,7 @@ namespace datalog {
expr_ref_vector conjs1(m), conjs(m);
rule_ref res(rm);
bool_rewriter bwr(m);
svector<bool> is_neg;
bool_vector is_neg;
tgt->get_vars(m, sorts1);
src.get_vars(m, sorts2);

2
src/muz/transforms/dl_mk_coi_filter.h
View file

@ -32,7 +32,7 @@ namespace datalog {
ast_manager & m;
context & m_context;
vector<app*> m_new_tail;
svector<bool> m_new_tail_neg;
bool_vector m_new_tail_neg;
rule_set * bottom_up(rule_set const & source);
rule_set * top_down(rule_set const & source);

2
src/muz/transforms/dl_mk_filter_rules.cpp
View file

@ -106,7 +106,7 @@ namespace datalog {
m_current = r;
app * new_head = r->get_head();
app_ref_vector new_tail(m);
svector<bool> new_is_negated;
bool_vector new_is_negated;
unsigned sz = r->get_tail_size();
bool rule_modified = false;
for (unsigned i = 0; i < sz; i++) {

4
src/muz/transforms/dl_mk_interp_tail_simplifier.h
View file

@ -38,7 +38,7 @@ namespace datalog {
unifier m_unif;
app_ref m_head;
app_ref_vector m_tail;
svector<bool> m_neg;
bool_vector m_neg;
rule * m_rule;
void apply(app * a, app_ref& res);
@ -76,7 +76,7 @@ namespace datalog {
app_ref_vector m_tail;
expr_ref_vector m_itail_members;
expr_ref_vector m_conj;
svector<bool> m_tail_neg;
bool_vector m_tail_neg;
normalizer_cfg* m_cfg;
normalizer_rw* m_rw;

2
src/muz/transforms/dl_mk_karr_invariants.h
View file

@ -34,7 +34,7 @@ namespace datalog {
struct matrix {
vector<vector<rational> > A;
vector<rational> b;
svector<bool> eq;
bool_vector eq;
unsigned size() const { return A.size(); }
void reset() { A.reset(); b.reset(); eq.reset(); }
matrix& operator=(matrix const& other);

4
src/muz/transforms/dl_mk_loop_counter.cpp
View file

@ -73,7 +73,7 @@ namespace datalog {
rule_ref new_rule(rm);
app_ref_vector tail(m);
app_ref head(m);
svector<bool> neg;
bool_vector neg;
rule_counter& vc = rm.get_counter();
for (unsigned i = 0; i < sz; ++i) {
tail.reset();
@ -129,7 +129,7 @@ namespace datalog {
rule_ref new_rule(rm);
app_ref_vector tail(m);
app_ref head(m);
svector<bool> neg;
bool_vector neg;
for (unsigned i = 0; i < sz; ++i) {
tail.reset();
neg.reset();

4
src/muz/transforms/dl_mk_magic_sets.cpp
View file

@ -187,7 +187,7 @@ namespace datalog {
void mk_magic_sets::create_magic_rules(app * head, unsigned tail_cnt, app * const * tail, bool const* negated, rule_set& result) {
//TODO: maybe include relevant interpreted predicates from the original rule
ptr_vector<app> new_tail;
svector<bool> negations;
bool_vector negations;
new_tail.push_back(create_magic_literal(head));
new_tail.append(tail_cnt, tail);
negations.push_back(false);
@ -231,7 +231,7 @@ namespace datalog {
}
ptr_vector<app> new_tail;
svector<bool> negations;
bool_vector negations;
while (new_tail.size()!=processed_tail_len) {
bool intentional = false;
int curr_index = pop_bound(exten_tails, r, bound_vars);

2
src/muz/transforms/dl_mk_magic_symbolic.cpp
View file

@ -77,7 +77,7 @@ namespace datalog {
rule_ref new_rule(rm);
app_ref_vector tail(m);
app_ref head(m);
svector<bool> neg;
bool_vector neg;
for (unsigned i = 0; i < sz; ++i) {
rule & r = *source.get_rule(i);
unsigned utsz = r.get_uninterpreted_tail_size();

8
src/muz/transforms/dl_mk_quantifier_abstraction.cpp
View file

@ -39,7 +39,7 @@ namespace datalog {
func_decl_ref_vector m_new_funcs;
vector<expr_ref_vector> m_subst;
vector<sort_ref_vector> m_sorts;
vector<svector<bool> > m_bound;
vector<bool_vector > m_bound;
public:
@ -56,7 +56,7 @@ namespace datalog {
void get_units(obj_map<expr, bool>& units) override { units.reset(); }
void insert(func_decl* old_p, func_decl* new_p, expr_ref_vector& sub, sort_ref_vector& sorts, svector<bool> const& bound) {
void insert(func_decl* old_p, func_decl* new_p, expr_ref_vector& sub, sort_ref_vector& sorts, bool_vector const& bound) {
m_old_funcs.push_back(old_p);
m_new_funcs.push_back(new_p);
m_subst.push_back(sub);
@ -71,7 +71,7 @@ namespace datalog {
func_decl* q = m_old_funcs[i].get();
expr_ref_vector const& sub = m_subst[i];
sort_ref_vector const& sorts = m_sorts[i];
svector<bool> const& is_bound = m_bound[i];
bool_vector const& is_bound = m_bound[i];
func_interp* f = old_model->get_func_interp(p);
expr_ref body(m);
unsigned arity_q = q->get_arity();
@ -177,7 +177,7 @@ namespace datalog {
func_decl* new_p = nullptr;
if (!m_old2new.find(old_p, new_p)) {
expr_ref_vector sub(m), vars(m);
svector<bool> bound;
bool_vector bound;
sort_ref_vector domain(m), sorts(m);
expr_ref arg(m);
for (unsigned i = 0; i < sz; ++i) {

14
src/muz/transforms/dl_mk_rule_inliner.cpp
View file

@ -91,7 +91,7 @@ namespace datalog {
void rule_unifier::apply(
rule const& r, bool is_tgt, unsigned skipped_index,
app_ref_vector& res, svector<bool>& res_neg) {
app_ref_vector& res, bool_vector& res_neg) {
unsigned rule_len = r.get_tail_size();
for (unsigned i = 0; i < rule_len; i++) {
if (i != skipped_index) { //i can never be UINT_MAX, so we'll never skip if we're not supposed to
@ -107,7 +107,7 @@ namespace datalog {
SASSERT(m_ready);
app_ref new_head(m);
app_ref_vector tail(m);
svector<bool> tail_neg;
bool_vector tail_neg;
rule_ref simpl_rule(m_rm);
apply(tgt.get_head(), true, new_head);
apply(tgt, true, tail_index, tail, tail_neg);
@ -647,8 +647,8 @@ namespace datalog {
}
void mk_rule_inliner::add_rule(rule_set const& source, rule* r, unsigned i) {
svector<bool>& can_remove = m_head_visitor.can_remove();
svector<bool>& can_expand = m_head_visitor.can_expand();
bool_vector& can_remove = m_head_visitor.can_remove();
bool_vector& can_expand = m_head_visitor.can_expand();
app* head = r->get_head();
func_decl* headd = head->get_decl();
m_head_visitor.add_position(head, i);
@ -705,8 +705,8 @@ namespace datalog {
}
// set up unification index.
svector<bool>& can_remove = m_head_visitor.can_remove();
svector<bool>& can_expand = m_head_visitor.can_expand();
bool_vector& can_remove = m_head_visitor.can_remove();
bool_vector& can_expand = m_head_visitor.can_expand();
for (unsigned i = 0; i < sz; ++i) {
add_rule(*rules, acc[i].get(), i);
@ -727,7 +727,7 @@ namespace datalog {
m_subst.reserve_vars(max_var+1);
m_subst.reserve_offsets(std::max(m_tail_index.get_approx_num_regs(), 2+m_head_index.get_approx_num_regs()));
svector<bool> valid;
bool_vector valid;
valid.reset();
valid.resize(sz, true);

8
src/muz/transforms/dl_mk_rule_inliner.h
View file

@ -76,7 +76,7 @@ namespace datalog {
unless skipped_index is equal to UINT_MAX
*/
void apply(rule const& r, bool is_tgt, unsigned skipped_index, app_ref_vector& res,
svector<bool>& res_neg);
bool_vector& res_neg);
};
@ -85,15 +85,15 @@ namespace datalog {
class visitor : public st_visitor {
context& m_context;
unsigned_vector m_unifiers;
svector<bool> m_can_remove, m_can_expand;
bool_vector m_can_remove, m_can_expand;
obj_map<expr, unsigned_vector> m_positions;
public:
visitor(context& c, substitution & s): st_visitor(s), m_context(c) { (void) m_context; }
bool operator()(expr* e) override;
void reset() { m_unifiers.reset(); }
void reset(unsigned sz);
svector<bool>& can_remove() { return m_can_remove; }
svector<bool>& can_expand() { return m_can_expand; }
bool_vector& can_remove() { return m_can_remove; }
bool_vector& can_expand() { return m_can_expand; }
unsigned_vector const& add_position(expr* e, unsigned j);
unsigned_vector const& del_position(expr* e, unsigned j);
unsigned_vector const& get_unifiers() { return m_unifiers; }

2
src/muz/transforms/dl_mk_scale.cpp
View file

@ -127,7 +127,7 @@ namespace datalog {
rule_ref new_rule(rm);
app_ref_vector tail(m);
app_ref head(m);
svector<bool> neg;
bool_vector neg;
ptr_vector<sort> vars;
ref<scale_model_converter> smc;
if (m_ctx.get_model_converter()) {

2
src/muz/transforms/dl_mk_separate_negated_tails.cpp
View file

@ -80,7 +80,7 @@ namespace datalog {
unsigned tsz = r.get_tail_size();
app_ref_vector tail(m);
app_ref p(m);
svector<bool> neg;
bool_vector neg;
for (unsigned i = 0; i < ptsz; ++i) {
tail.push_back(r.get_tail(i));
neg.push_back(false);

6
src/muz/transforms/dl_mk_slice.h
View file

@ -35,10 +35,10 @@ namespace datalog {
context& m_ctx;
ast_manager& m;
rule_manager& rm;
svector<bool> m_input;
svector<bool> m_output;
bool_vector m_input;
bool_vector m_output;
expr_ref_vector m_solved_vars;
svector<bool> m_var_is_sliceable;
bool_vector m_var_is_sliceable;
obj_map<func_decl, func_decl*> m_predicates;
obj_map<func_decl, bit_vector> m_sliceable;
ast_ref_vector m_pinned;

2
src/muz/transforms/dl_mk_subsumption_checker.cpp
View file

@ -125,7 +125,7 @@ namespace datalog {
app_ref head(r->get_head(), m);
app_ref_vector tail(m);
svector<bool> tail_neg;
bool_vector tail_neg;
for(unsigned i=0; i<u_len; i++) {
app * tail_atom = r->get_tail(i);

8
src/muz/transforms/dl_mk_synchronize.cpp
View file

@ -101,7 +101,7 @@ namespace datalog {
app_ref replacing = product_application(apps);
ptr_vector<app> new_tail;
svector<bool> new_tail_neg;
bool_vector new_tail_neg;
unsigned n = r.get_tail_size() - apps.size() + 1;
unsigned tail_idx = 0;
new_tail.resize(n);
@ -176,7 +176,7 @@ namespace datalog {
void mk_synchronize::add_rec_tail(vector< ptr_vector<app> > & recursive_calls,
app_ref_vector & new_tail,
svector<bool> & new_tail_neg,
bool_vector & new_tail_neg,
unsigned & tail_idx) {
unsigned max_sz = 0;
for (auto &rc : recursive_calls)
@ -200,7 +200,7 @@ namespace datalog {
}
void mk_synchronize::add_non_rec_tail(rule & r, app_ref_vector & new_tail,
svector<bool> & new_tail_neg,
bool_vector & new_tail_neg,
unsigned & tail_idx) {
for (unsigned i = 0, sz = r.get_positive_tail_size(); i < sz; ++i) {
app* tail = r.get_tail(i);
@ -287,7 +287,7 @@ namespace datalog {
}
app_ref_vector new_tail(m);
svector<bool> new_tail_neg;
bool_vector new_tail_neg;
new_tail.resize(product_tail_length);
new_tail_neg.resize(product_tail_length);
unsigned tail_idx = -1;

4
src/muz/transforms/dl_mk_synchronize.h
View file

@ -109,9 +109,9 @@ namespace datalog {
void add_rec_tail(vector< ptr_vector<app> > & recursive_calls,
app_ref_vector & new_tail,
svector<bool> & new_tail_neg, unsigned & tail_idx);
bool_vector & new_tail_neg, unsigned & tail_idx);
void add_non_rec_tail(rule & r, app_ref_vector & new_tail,
svector<bool> & new_tail_neg,
bool_vector & new_tail_neg,
unsigned & tail_idx);
rule_ref product_rule(rule_ref_vector const & rules);

2
src/muz/transforms/dl_mk_unbound_compressor.cpp
View file

@ -205,7 +205,7 @@ namespace datalog {
SASSERT(dtail_args.size()==dtail_pred->get_arity());
app_ref dtail(m.mk_app(dtail_pred, dtail_args.size(), dtail_args.c_ptr()), m);
svector<bool> tails_negated;
bool_vector tails_negated;
app_ref_vector tails(m);
unsigned tail_len = r->get_tail_size();
for (unsigned i = 0; i < tail_len; i++) {