diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index e8de0c7e4..f8e8c53b1 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -110,6 +110,9 @@ else() set(lib_type "STATIC") endif() add_library(libz3 ${lib_type} ${object_files}) +target_include_directories(libz3 INTERFACE + $ + $) set_target_properties(libz3 PROPERTIES # VERSION determines the version in the filename of the shared library. # SOVERSION determines the value of the DT_SONAME field on ELF platforms. diff --git a/src/ast/array_decl_plugin.cpp b/src/ast/array_decl_plugin.cpp index 08b55bba3..b2c7edc34 100644 --- a/src/ast/array_decl_plugin.cpp +++ b/src/ast/array_decl_plugin.cpp @@ -129,7 +129,7 @@ func_decl * array_decl_plugin::mk_const(sort * s, unsigned arity, sort * const * m_manager->raise_exception("invalid const array definition, parameter is not an array sort"); return nullptr; } - if (!m_manager->compatible_sorts(get_array_range(s), domain[0])) { + if (get_array_range(s) != domain[0]) { m_manager->raise_exception("invalid const array definition, sort mismatch between array range and argument"); return nullptr; } diff --git a/src/opt/maxsmt.cpp b/src/opt/maxsmt.cpp index d5f332edb..f116da8e5 100644 --- a/src/opt/maxsmt.cpp +++ b/src/opt/maxsmt.cpp @@ -126,14 +126,14 @@ namespace opt { wth->reset_local(); } else { - wth = alloc(smt::theory_wmaxsat, m, m_c.fm()); + wth = alloc(smt::theory_wmaxsat, m_c.smt_context(), m, m_c.fm()); m_c.smt_context().register_plugin(wth); } smt::theory_id th_pb = m.get_family_id("pb"); smt::theory_pb* pb = dynamic_cast(m_c.smt_context().get_theory(th_pb)); if (!pb) { theory_pb_params params; - pb = alloc(smt::theory_pb, m, params); + pb = alloc(smt::theory_pb, m_c.smt_context()); m_c.smt_context().register_plugin(pb); } return wth; diff --git a/src/opt/opt_solver.cpp b/src/opt/opt_solver.cpp index 72e9c3ea3..97aa54d4a 100644 --- a/src/opt/opt_solver.cpp +++ b/src/opt/opt_solver.cpp @@ -109,7 +109,7 @@ namespace opt { smt::theory_id th_id = m.get_family_id("pb"); smt::theory* th = get_context().get_theory(th_id); if (!th) { - get_context().register_plugin(alloc(smt::theory_pb, m, m_params)); + get_context().register_plugin(alloc(smt::theory_pb, get_context())); } } @@ -119,7 +119,7 @@ namespace opt { smt::theory* arith_theory = ctx.get_theory(arith_id); if (!arith_theory) { - ctx.register_plugin(alloc(smt::theory_mi_arith, m, m_params)); + ctx.register_plugin(alloc(smt::theory_mi_arith, ctx)); arith_theory = ctx.get_theory(arith_id); SASSERT(arith_theory); } diff --git a/src/smt/arith_eq_adapter.cpp b/src/smt/arith_eq_adapter.cpp index bc381b822..50b6aa4e2 100644 --- a/src/smt/arith_eq_adapter.cpp +++ b/src/smt/arith_eq_adapter.cpp @@ -210,7 +210,7 @@ namespace smt { << " " << mk_pp(ge, m) << ": " << ge_lit << " " << mk_pp(t1_eq_t2, m) << ": " << t1_eq_t2_lit << "\n";); - if (m_params.m_arith_add_binary_bounds) { + if (m_owner.get_fparams().m_arith_add_binary_bounds) { TRACE("arith_eq_adapter", tout << "adding binary bounds...\n";); ctx.mk_th_axiom(tid, le_lit, ge_lit, m_proof_hint.size(), m_proof_hint.c_ptr()); } @@ -219,7 +219,7 @@ namespace smt { ctx.add_relevancy_eh(n1->get_owner(), eh); ctx.add_relevancy_eh(n2->get_owner(), eh); } - if (!m_params.m_arith_lazy_adapter && !ctx.at_base_level() && + if (!m_owner.get_fparams().m_arith_lazy_adapter && !ctx.at_base_level() && n1->get_iscope_lvl() <= ctx.get_base_level() && n2->get_iscope_lvl() <= ctx.get_base_level()) { m_restart_pairs.push_back(enode_pair(n1, n2)); } diff --git a/src/smt/arith_eq_adapter.h b/src/smt/arith_eq_adapter.h index 42aae6821..8e2a92139 100644 --- a/src/smt/arith_eq_adapter.h +++ b/src/smt/arith_eq_adapter.h @@ -62,7 +62,6 @@ namespace smt { private: theory & m_owner; - theory_arith_params & m_params; arith_util & m_util; already_processed m_already_processed; @@ -74,7 +73,7 @@ namespace smt { enode * get_enode(theory_var v) const { return m_owner.get_enode(v); } public: - arith_eq_adapter(theory & owner, theory_arith_params & params, arith_util & u):m_owner(owner), m_params(params), m_util(u) {} + arith_eq_adapter(theory & owner, arith_util & u):m_owner(owner), m_util(u) {} void new_eq_eh(theory_var v1, theory_var v2); void new_diseq_eh(theory_var v1, theory_var v2); void reset_eh(); diff --git a/src/smt/seq_eq_solver.cpp b/src/smt/seq_eq_solver.cpp index 82b549872..0db03e952 100644 --- a/src/smt/seq_eq_solver.cpp +++ b/src/smt/seq_eq_solver.cpp @@ -28,7 +28,6 @@ using namespace smt; bool theory_seq::solve_eqs(unsigned i) { - context& ctx = get_context(); bool change = false; for (; !ctx.inconsistent() && i < m_eqs.size(); ++i) { if (solve_eq(i)) { @@ -43,7 +42,6 @@ bool theory_seq::solve_eqs(unsigned i) { bool theory_seq::solve_eq(unsigned idx) { const eq& e = m_eqs[idx]; - context& ctx = get_context(); expr_ref_vector& ls = m_ls; expr_ref_vector& rs = m_rs; m_ls.reset(); @@ -126,7 +124,6 @@ bool theory_seq::solve_unit_eq(expr_ref_vector const& l, expr_ref_vector const& } bool theory_seq::solve_binary_eq(expr_ref_vector const& ls, expr_ref_vector const& rs, dependency* dep) { - context& ctx = get_context(); ptr_vector xs, ys; expr_ref x(m), y(m); if (!is_binary_eq(ls, rs, x, xs, ys, y) && @@ -254,8 +251,6 @@ bool theory_seq::find_better_rep(expr_ref_vector const& ls, expr_ref_vector cons // disabled until functionality is clarified return false; - context& ctx = get_context(); - if (ls.empty() || rs.empty()) return false; expr* l_fst = find_fst_non_empty_var(ls); @@ -328,7 +323,6 @@ bool theory_seq::find_better_rep(expr_ref_vector const& ls, expr_ref_vector cons } bool theory_seq::has_len_offset(expr_ref_vector const& ls, expr_ref_vector const& rs, int & offset) { - context& ctx = get_context(); if (ls.empty() || rs.empty()) return false; @@ -407,7 +401,6 @@ bool theory_seq::len_based_split() { */ bool theory_seq::len_based_split(eq const& e) { - context& ctx = get_context(); expr_ref_vector const& ls = e.ls(); expr_ref_vector const& rs = e.rs(); @@ -537,7 +530,6 @@ bool theory_seq::is_complex(eq const& e) { bool theory_seq::split_lengths(dependency* dep, expr_ref_vector const& ls, expr_ref_vector const& rs, vector const& ll, vector const& rl) { - context& ctx = get_context(); expr_ref X(m), Y(m), b(m); if (ls.empty() || rs.empty()) { return false; @@ -646,7 +638,6 @@ bool theory_seq::branch_binary_variable(eq const& e) { // x is either a prefix of ys, all of ys ++ y or ys ++ y1, such that y = y1 ++ y2, y2 = xs rational lenX, lenY; - context& ctx = get_context(); if (branch_variable_eq(e)) { return true; } @@ -713,7 +704,6 @@ bool theory_seq::branch_unit_variable() { void theory_seq::branch_unit_variable(dependency* dep, expr* X, expr_ref_vector const& units) { SASSERT(is_var(X)); - context& ctx = get_context(); rational lenX; if (!get_length(X, lenX)) { TRACE("seq", tout << "enforce length on " << mk_bounded_pp(X, m, 2) << "\n";); @@ -748,7 +738,7 @@ void theory_seq::branch_unit_variable(dependency* dep, expr* X, expr_ref_vector } bool theory_seq::branch_ternary_variable1() { - int start = get_context().get_random_value(); + int start = ctx.get_random_value(); for (unsigned i = 0; i < m_eqs.size(); ++i) { if (branch_ternary_variable(m_eqs[(i + start) % m_eqs.size()])) return true; @@ -759,7 +749,7 @@ bool theory_seq::branch_ternary_variable1() { } bool theory_seq::branch_ternary_variable2() { - int start = get_context().get_random_value(); + int start = ctx.get_random_value(); for (unsigned i = 0; i < m_eqs.size(); ++i) { eq const& e = m_eqs[(i + start) % m_eqs.size()]; if (branch_ternary_variable(e, true)) { @@ -842,7 +832,6 @@ unsigned_vector theory_seq::overlap2(expr_ref_vector const& ls, expr_ref_vector bool theory_seq::branch_ternary_variable_base( dependency* dep, unsigned_vector const& indexes, expr* x, expr_ref_vector const& xs, expr* y1, expr_ref_vector const& ys, expr* y2) { - context& ctx = get_context(); bool change = false; for (auto ind : indexes) { TRACE("seq", tout << "ind = " << ind << "\n";); @@ -892,7 +881,6 @@ bool theory_seq::branch_ternary_variable(eq const& e, bool flag1) { } rational lenX, lenY1, lenY2; - context& ctx = get_context(); if (!get_length(x, lenX)) { add_length_to_eqc(x); } @@ -942,7 +930,6 @@ bool theory_seq::branch_ternary_variable(eq const& e, bool flag1) { bool theory_seq::branch_ternary_variable_base2( dependency* dep, unsigned_vector const& indexes, expr_ref_vector const& xs, expr* x, expr* y1, expr_ref_vector const& ys, expr* y2) { - context& ctx = get_context(); sort* srt = m.get_sort(x); bool change = false; for (auto ind : indexes) { @@ -990,7 +977,6 @@ bool theory_seq::branch_ternary_variable2(eq const& e, bool flag1) { dependency* dep = e.dep(); rational lenX, lenY1, lenY2; - context& ctx = get_context(); if (!get_length(x, lenX)) { add_length_to_eqc(x); } @@ -1058,7 +1044,6 @@ bool theory_seq::branch_quat_variable(eq const& e) { dependency* dep = e.dep(); rational lenX1, lenX2, lenY1, lenY2; - context& ctx = get_context(); if (!get_length(x1, lenX1)) { add_length_to_eqc(x1); } @@ -1115,7 +1100,6 @@ bool theory_seq::branch_quat_variable(eq const& e) { int theory_seq::find_fst_non_empty_idx(expr_ref_vector const& xs) { - context & ctx = get_context(); for (unsigned i = 0; i < xs.size(); ++i) { expr* x = xs[i]; if (!is_var(x)) return -1; @@ -1140,7 +1124,6 @@ expr* theory_seq::find_fst_non_empty_var(expr_ref_vector const& x) { } bool theory_seq::branch_variable_eq() { - context& ctx = get_context(); unsigned sz = m_eqs.size(); int start = ctx.get_random_value(); @@ -1195,7 +1178,7 @@ bool theory_seq::find_branch_candidate(unsigned& start, dependency* dep, expr_re return false; } - TRACE("seq", tout << mk_pp(l, m) << ": " << get_context().get_scope_level() << " - start:" << start << "\n";); + TRACE("seq", tout << mk_pp(l, m) << ": " << ctx.get_scope_level() << " - start:" << start << "\n";); expr_ref v0(m); v0 = m_util.str.mk_empty(m.get_sort(l)); @@ -1228,7 +1211,6 @@ bool theory_seq::find_branch_candidate(unsigned& start, dependency* dep, expr_re all_units &= m_util.str.is_unit(r); } if (all_units) { - context& ctx = get_context(); literal_vector lits; lits.push_back(~mk_eq_empty(l)); for (unsigned i = 0; i < rs.size(); ++i) { @@ -1282,7 +1264,6 @@ bool theory_seq::can_be_equal(unsigned szl, expr* const* ls, unsigned szr, expr* lbool theory_seq::assume_equality(expr* l, expr* r) { - context& ctx = get_context(); if (m_exclude.contains(l, r)) { return l_false; } @@ -1400,7 +1381,7 @@ bool theory_seq::check_length_coherence0(expr* e) { } if (p || r != l_false) { - if (!get_context().at_base_level()) { + if (!ctx.at_base_level()) { m_trail_stack.push(push_replay(alloc(replay_length_coherence, m, e))); } return true; @@ -1440,7 +1421,6 @@ bool theory_seq::check_length_coherence() { } bool theory_seq::reduce_length_eq() { - context& ctx = get_context(); int start = ctx.get_random_value(); for (unsigned i = 0; !ctx.inconsistent() && i < m_eqs.size(); ++i) { diff --git a/src/smt/seq_ne_solver.cpp b/src/smt/seq_ne_solver.cpp index 76b17e2b8..53dc9f322 100644 --- a/src/smt/seq_ne_solver.cpp +++ b/src/smt/seq_ne_solver.cpp @@ -26,7 +26,6 @@ Author: using namespace smt; bool theory_seq::solve_nqs(unsigned i) { - context & ctx = get_context(); for (; !ctx.inconsistent() && i < m_nqs.size(); ++i) { if (solve_ne(i)) { m_nqs.erase_and_swap(i--); @@ -48,7 +47,6 @@ bool theory_seq::solve_ne(unsigned idx) { bool theory_seq::check_ne_literals(unsigned idx, unsigned& num_undef_lits) { ne const& n = m_nqs[idx]; - context& ctx = get_context(); for (literal lit : n.lits()) { switch (ctx.get_assignment(lit)) { case l_false: @@ -73,7 +71,6 @@ bool theory_seq::check_ne_literals(unsigned idx, unsigned& num_undef_lits) { bool theory_seq::propagate_ne2lit(unsigned idx) { ne const& n = m_nqs[idx]; - context& ctx = get_context(); if (!n.eqs().empty()) { return false; } @@ -145,7 +142,6 @@ bool theory_seq::propagate_ne2eq(unsigned idx, expr_ref_vector const& es) { bool theory_seq::reduce_ne(unsigned idx) { ne const& n = m_nqs[idx]; - context& ctx = get_context(); bool updated = false; dependency* new_deps = n.dep(); vector new_eqs; @@ -257,7 +253,6 @@ bool theory_seq::branch_nqs() { lbool theory_seq::branch_nq(ne const& n) { - context& ctx = get_context(); literal eq_len = mk_eq(mk_len(n.l()), mk_len(n.r()), false); ctx.mark_as_relevant(eq_len); switch (ctx.get_assignment(eq_len)) { diff --git a/src/smt/smt_context.cpp b/src/smt/smt_context.cpp index eac12c0d6..5fb36a28b 100644 --- a/src/smt/smt_context.cpp +++ b/src/smt/smt_context.cpp @@ -2832,9 +2832,8 @@ namespace smt { } TRACE("internalize", tout << this << " " << th->get_family_id() << "\n";); SASSERT(std::find(m_theory_set.begin(), m_theory_set.end(), th) == m_theory_set.end()); - SASSERT(!already_internalized_theory(th)); - th->init(this); m_theories.register_plugin(th); + th->init(); m_theory_set.push_back(th); { #ifdef Z3DEBUG @@ -4475,7 +4474,7 @@ namespace smt { bool context::has_case_splits() { for (unsigned i = get_num_b_internalized(); i-- > 0; ) { - if (get_assignment(i) == l_undef) + if (is_relevant(i) && get_assignment(i) == l_undef) return true; } return false; diff --git a/src/smt/smt_setup.cpp b/src/smt/smt_setup.cpp index 0478b878d..2e2e9da0f 100644 --- a/src/smt/smt_setup.cpp +++ b/src/smt/smt_setup.cpp @@ -232,7 +232,7 @@ namespace smt { void setup::setup_QF_BVRE() { setup_QF_BV(); setup_QF_LIA(); - m_context.register_plugin(alloc(theory_seq, m_manager, m_params)); + m_context.register_plugin(alloc(theory_seq, m_context)); } void setup::setup_QF_UF(static_features const & st) { @@ -302,19 +302,19 @@ namespace smt { // to compute the actual value of epsilon even if the input does not have rational numbers. // Example: (x < 1) and (x > 0) if (m_manager.proofs_enabled()) { - m_context.register_plugin(alloc(smt::theory_mi_arith, m_manager, m_params)); + m_context.register_plugin(alloc(smt::theory_mi_arith, m_context)); } else { if (m_params.m_arith_auto_config_simplex || st.m_num_uninterpreted_constants > 4 * st.m_num_bool_constants || st.m_num_ite_terms > 0 /* theory_rdl and theory_frdl do not support ite-terms */) { // if (!st.m_has_rational && !m_params.m_model && st.arith_k_sum_is_small()) { // TRACE("rdl_bug", tout << "using theory_smi_arith\n";); - // m_context.register_plugin(alloc(smt::theory_smi_arith, m_manager, m_params)); + // m_context.register_plugin(alloc(smt::theory_smi_arith, m_context)); // } // else { TRACE("rdl_bug", tout << "using theory_mi_arith\n";); //setup_lra_arith(); - m_context.register_plugin(alloc(smt::theory_mi_arith, m_manager, m_params)); + m_context.register_plugin(alloc(smt::theory_mi_arith, m_context)); // } } else { @@ -322,9 +322,9 @@ namespace smt { m_params.m_arith_propagation_strategy = ARITH_PROP_AGILITY; m_params.m_arith_add_binary_bounds = true; if (!st.m_has_rational && !m_params.m_model && st.arith_k_sum_is_small()) - m_context.register_plugin(alloc(smt::theory_frdl, m_manager, m_params)); + m_context.register_plugin(alloc(smt::theory_frdl, m_context)); else - m_context.register_plugin(alloc(smt::theory_rdl, m_manager, m_params)); + m_context.register_plugin(alloc(smt::theory_rdl, m_context)); } } } @@ -375,25 +375,25 @@ namespace smt { tout << "ARITH_EQ_BOUNDS: " << m_params.m_arith_eq_bounds << "\n";); if (m_manager.proofs_enabled()) { - m_context.register_plugin(alloc(smt::theory_mi_arith, m_manager, m_params)); + m_context.register_plugin(alloc(smt::theory_mi_arith, m_context)); } else if (!m_params.m_arith_auto_config_simplex && is_dense(st)) { TRACE("setup", tout << "using dense diff logic...\n";); m_params.m_phase_selection = PS_CACHING_CONSERVATIVE; if (st.arith_k_sum_is_small()) - m_context.register_plugin(alloc(smt::theory_dense_si, m_manager, m_params)); + m_context.register_plugin(alloc(smt::theory_dense_si, m_context)); else - m_context.register_plugin(alloc(smt::theory_dense_i, m_manager, m_params)); - + m_context.register_plugin(alloc(smt::theory_dense_i, m_context)); + } else { // if (st.arith_k_sum_is_small()) { - // TRACE("setup", tout << "using small integer simplex...\n";); - // m_context.register_plugin(alloc(smt::theory_si_arith, m_manager, m_params)); + // TRACE("setup", tout << "using small integer simplex...\n"; + // m_context.register_plugin(alloc(smt::theory_si_arith, m_context)); // } // else { TRACE("setup", tout << "using big integer simplex...\n";); - m_context.register_plugin(alloc(smt::theory_i_arith, m_manager, m_params)); + m_context.register_plugin(alloc(smt::theory_i_arith, m_context)); // } } } @@ -428,12 +428,12 @@ namespace smt { m_params.m_restart_strategy = RS_GEOMETRIC; if (m_manager.proofs_enabled()) { - m_context.register_plugin(alloc(smt::theory_mi_arith, m_manager, m_params)); + m_context.register_plugin(alloc(smt::theory_mi_arith, m_context)); } else if (st.arith_k_sum_is_small()) - m_context.register_plugin(alloc(smt::theory_dense_si, m_manager, m_params)); + m_context.register_plugin(alloc(smt::theory_dense_si, m_context)); else - m_context.register_plugin(alloc(smt::theory_dense_i, m_manager, m_params)); + m_context.register_plugin(alloc(smt::theory_dense_i, m_context)); return; } } @@ -443,12 +443,12 @@ namespace smt { m_params.m_restart_factor = 1.5; m_params.m_restart_adaptive = false; if (m_manager.proofs_enabled()) { - m_context.register_plugin(alloc(smt::theory_mi_arith, m_manager, m_params)); + m_context.register_plugin(alloc(smt::theory_mi_arith, m_context)); } // else if (st.arith_k_sum_is_small()) - // m_context.register_plugin(alloc(smt::theory_dense_si, m_manager, m_params)); + // m_context.register_plugin(alloc(smt::theory_dense_si, m_context)); else - m_context.register_plugin(alloc(smt::theory_i_arith, m_manager, m_params)); + m_context.register_plugin(alloc(smt::theory_i_arith, m_context)); } void setup::setup_QF_LRA() { @@ -567,7 +567,7 @@ namespace smt { m_params.m_bv_cc = false; m_params.m_bb_ext_gates = true; m_params.m_nnf_cnf = false; - m_context.register_plugin(alloc(smt::theory_bv, m_manager, m_params)); + m_context.register_plugin(alloc(smt::theory_bv, m_context)); } void setup::setup_QF_AUFBV() { @@ -576,7 +576,7 @@ namespace smt { m_params.m_bv_cc = false; m_params.m_bb_ext_gates = true; m_params.m_nnf_cnf = false; - m_context.register_plugin(alloc(smt::theory_bv, m_manager, m_params)); + m_context.register_plugin(alloc(smt::theory_bv, m_context)); setup_arrays(); } @@ -653,7 +653,7 @@ namespace smt { // m_params.m_ng_lift_ite = LI_FULL; TRACE("setup", tout << "max_eager_multipatterns: " << m_params.m_qi_max_eager_multipatterns << "\n";); - m_context.register_plugin(alloc(smt::theory_i_arith, m_manager, m_params)); + m_context.register_plugin(alloc(smt::theory_i_arith, m_context)); setup_arrays(); } @@ -711,12 +711,12 @@ namespace smt { void setup::setup_QF_FP() { setup_QF_BV(); - m_context.register_plugin(alloc(smt::theory_fpa, m_manager)); + m_context.register_plugin(alloc(smt::theory_fpa, m_context)); } void setup::setup_QF_FPBV() { setup_QF_BV(); - m_context.register_plugin(alloc(smt::theory_fpa, m_manager)); + m_context.register_plugin(alloc(smt::theory_fpa, m_context)); } void setup::setup_QF_S() { @@ -731,7 +731,7 @@ namespace smt { } else if (m_params.m_string_solver == "empty") { - m_context.register_plugin(alloc(smt::theory_seq_empty, m_manager)); + m_context.register_plugin(alloc(smt::theory_seq_empty, m_context)); } else if (m_params.m_string_solver == "none") { // don't register any solver. @@ -747,7 +747,7 @@ namespace smt { void setup::setup_i_arith() { if (AS_OLD_ARITH == m_params.m_arith_mode) { - m_context.register_plugin(alloc(smt::theory_i_arith, m_manager, m_params)); + m_context.register_plugin(alloc(smt::theory_i_arith, m_context)); } else { setup_lra_arith(); @@ -755,20 +755,19 @@ namespace smt { } void setup::setup_lra_arith() { - // m_context.register_plugin(alloc(smt::theory_mi_arith, m_manager, m_params)); - m_context.register_plugin(alloc(smt::theory_lra, m_manager, m_params)); + m_context.register_plugin(alloc(smt::theory_lra, m_context)); } void setup::setup_mi_arith() { switch (m_params.m_arith_mode) { case AS_OPTINF: - m_context.register_plugin(alloc(smt::theory_inf_arith, m_manager, m_params)); + m_context.register_plugin(alloc(smt::theory_inf_arith, m_context)); break; case AS_NEW_ARITH: setup_lra_arith(); break; default: - m_context.register_plugin(alloc(smt::theory_mi_arith, m_manager, m_params)); + m_context.register_plugin(alloc(smt::theory_mi_arith, m_context)); break; } } @@ -790,59 +789,59 @@ namespace smt { } switch(mode) { case AS_NO_ARITH: - m_context.register_plugin(alloc(smt::theory_dummy, m_manager.mk_family_id("arith"), "no arithmetic")); + m_context.register_plugin(alloc(smt::theory_dummy, m_context, m_manager.mk_family_id("arith"), "no arithmetic")); break; case AS_DIFF_LOGIC: m_params.m_arith_eq2ineq = true; if (fixnum) { if (int_only) - m_context.register_plugin(alloc(smt::theory_fidl, m_manager, m_params)); + m_context.register_plugin(alloc(smt::theory_fidl, m_context)); else - m_context.register_plugin(alloc(smt::theory_frdl, m_manager, m_params)); + m_context.register_plugin(alloc(smt::theory_frdl, m_context)); } else { if (int_only) - m_context.register_plugin(alloc(smt::theory_idl, m_manager, m_params)); + m_context.register_plugin(alloc(smt::theory_idl, m_context)); else - m_context.register_plugin(alloc(smt::theory_rdl, m_manager, m_params)); - } + m_context.register_plugin(alloc(smt::theory_rdl, m_context)); + } break; case AS_DENSE_DIFF_LOGIC: m_params.m_arith_eq2ineq = true; if (fixnum) { if (int_only) - m_context.register_plugin(alloc(smt::theory_dense_si, m_manager, m_params)); + m_context.register_plugin(alloc(smt::theory_dense_si, m_context)); else - m_context.register_plugin(alloc(smt::theory_dense_smi, m_manager, m_params)); + m_context.register_plugin(alloc(smt::theory_dense_smi, m_context)); } else { if (int_only) - m_context.register_plugin(alloc(smt::theory_dense_i, m_manager, m_params)); + m_context.register_plugin(alloc(smt::theory_dense_i, m_context)); else - m_context.register_plugin(alloc(smt::theory_dense_mi, m_manager, m_params)); + m_context.register_plugin(alloc(smt::theory_dense_mi, m_context)); } break; case AS_UTVPI: m_params.m_arith_eq2ineq = true; if (int_only) - m_context.register_plugin(alloc(smt::theory_iutvpi, m_manager)); + m_context.register_plugin(alloc(smt::theory_iutvpi, m_context)); else - m_context.register_plugin(alloc(smt::theory_rutvpi, m_manager)); + m_context.register_plugin(alloc(smt::theory_rutvpi, m_context)); break; case AS_OPTINF: - m_context.register_plugin(alloc(smt::theory_inf_arith, m_manager, m_params)); + m_context.register_plugin(alloc(smt::theory_inf_arith, m_context)); break; case AS_OLD_ARITH: if (m_params.m_arith_int_only && int_only) - m_context.register_plugin(alloc(smt::theory_i_arith, m_manager, m_params)); + m_context.register_plugin(alloc(smt::theory_i_arith, m_context)); else - m_context.register_plugin(alloc(smt::theory_mi_arith, m_manager, m_params)); + m_context.register_plugin(alloc(smt::theory_mi_arith, m_context)); break; case AS_NEW_ARITH: setup_lra_arith(); break; default: - m_context.register_plugin(alloc(smt::theory_mi_arith, m_manager, m_params)); + m_context.register_plugin(alloc(smt::theory_mi_arith, m_context)); break; } } @@ -850,10 +849,10 @@ namespace smt { void setup::setup_bv() { switch(m_params.m_bv_mode) { case BS_NO_BV: - m_context.register_plugin(alloc(smt::theory_dummy, m_manager.mk_family_id("bv"), "no bit-vector")); + m_context.register_plugin(alloc(smt::theory_dummy, m_context, m_manager.mk_family_id("bv"), "no bit-vector")); break; case BS_BLASTER: - m_context.register_plugin(alloc(smt::theory_bv, m_manager, m_params)); + m_context.register_plugin(alloc(smt::theory_bv, m_context)); break; } } @@ -861,33 +860,33 @@ namespace smt { void setup::setup_arrays() { switch(m_params.m_array_mode) { case AR_NO_ARRAY: - m_context.register_plugin(alloc(smt::theory_dummy, m_manager.mk_family_id("array"), "no array")); + m_context.register_plugin(alloc(smt::theory_dummy, m_context, m_manager.mk_family_id("array"), "no array")); break; case AR_SIMPLE: - m_context.register_plugin(alloc(smt::theory_array, m_manager, m_params)); + m_context.register_plugin(alloc(smt::theory_array, m_context)); break; case AR_MODEL_BASED: throw default_exception("The model-based array theory solver is deprecated"); break; case AR_FULL: - m_context.register_plugin(alloc(smt::theory_array_full, m_manager, m_params)); + m_context.register_plugin(alloc(smt::theory_array_full, m_context)); break; } } void setup::setup_datatypes() { TRACE("datatype", tout << "registering theory datatype...\n";); - m_context.register_plugin(alloc(theory_datatype, m_manager)); + m_context.register_plugin(alloc(theory_datatype, m_context)); } void setup::setup_recfuns() { TRACE("recfun", tout << "registering theory recfun...\n";); - theory_recfun * th = alloc(theory_recfun, m_manager); + theory_recfun * th = alloc(theory_recfun, m_context); m_context.register_plugin(th); } void setup::setup_dl() { - m_context.register_plugin(mk_theory_dl(m_manager)); + m_context.register_plugin(mk_theory_dl(m_context)); } void setup::setup_seq_str(static_features const & st) { @@ -899,7 +898,7 @@ namespace smt { setup_seq(); } else if (m_params.m_string_solver == "empty") { - m_context.register_plugin(alloc(smt::theory_seq_empty, m_manager)); + m_context.register_plugin(alloc(smt::theory_seq_empty, m_context)); } else if (m_params.m_string_solver == "none") { // don't register any solver. @@ -918,30 +917,30 @@ namespace smt { } void setup::setup_card() { - m_context.register_plugin(alloc(theory_pb, m_manager, m_params)); + m_context.register_plugin(alloc(theory_pb, m_context)); } void setup::setup_fpa() { setup_bv(); - m_context.register_plugin(alloc(theory_fpa, m_manager)); + m_context.register_plugin(alloc(theory_fpa, m_context)); } void setup::setup_str() { setup_arith(); - m_context.register_plugin(alloc(theory_str, m_manager, m_params)); + m_context.register_plugin(alloc(theory_str, m_context, m_manager, m_params)); } void setup::setup_seq() { - m_context.register_plugin(alloc(smt::theory_seq, m_manager, m_params)); + m_context.register_plugin(alloc(smt::theory_seq, m_context)); } void setup::setup_CSP() { setup_unknown(); - m_context.register_plugin(alloc(smt::theory_jobscheduler, m_manager)); + m_context.register_plugin(alloc(smt::theory_jobscheduler, m_context)); } void setup::setup_special_relations() { - m_context.register_plugin(alloc(smt::theory_special_relations, m_manager)); + m_context.register_plugin(alloc(smt::theory_special_relations, m_context, m_manager)); } void setup::setup_unknown() { diff --git a/src/smt/smt_theory.cpp b/src/smt/smt_theory.cpp index c1e0e25fe..5e11e7a66 100644 --- a/src/smt/smt_theory.cpp +++ b/src/smt/smt_theory.cpp @@ -22,23 +22,15 @@ Revision History: namespace smt { - void theory::init(context * ctx) { - SASSERT(m_context == 0); - m_context = ctx; - m_manager = &(ctx->get_manager()); - } - void theory::reset_eh() { m_var2enode.reset(); } void theory::push_scope_eh() { - SASSERT(m_context); m_var2enode_lim.push_back(m_var2enode.size()); } void theory::pop_scope_eh(unsigned num_scopes) { - SASSERT(m_context); unsigned scope_lvl = m_var2enode_lim.size(); SASSERT(num_scopes <= scope_lvl); unsigned new_lvl = scope_lvl - num_scopes; @@ -109,19 +101,17 @@ namespace smt { } bool theory::is_relevant_and_shared(enode * n) const { - context & ctx = get_context(); return ctx.is_relevant(n) && ctx.is_shared(n); } bool theory::assume_eq(enode * n1, enode * n2) { - return get_context().assume_eq(n1, n2); + return ctx.assume_eq(n1, n2); } literal theory::mk_eq(expr * a, expr * b, bool gate_ctx) { if (a == b) { return true_literal; } - context & ctx = get_context(); app_ref eq(ctx.mk_eq_atom(a, b), get_manager()); TRACE("mk_var_bug", tout << "mk_eq: " << eq->get_id() << " " << a->get_id() << " " << b->get_id() << "\n"; tout << mk_ll_pp(a, get_manager()) << "\n" << mk_ll_pp(b, get_manager());); @@ -130,7 +120,6 @@ namespace smt { } literal theory::mk_preferred_eq(expr* a, expr* b) { - context& ctx = get_context(); ctx.assume_eq(ensure_enode(a), ensure_enode(b)); literal lit = mk_eq(a, b, false); ctx.force_phase(lit); @@ -138,7 +127,6 @@ namespace smt { } enode* theory::ensure_enode(expr* e) { - context& ctx = get_context(); if (!ctx.e_internalized(e)) { ctx.internalize(e, false); } @@ -147,22 +135,25 @@ namespace smt { return n; } - theory::theory(family_id fid): + theory::theory(context& ctx, family_id fid): m_id(fid), - m_context(nullptr), - m_manager(nullptr) { + ctx(ctx), + m(ctx.get_manager()) { } theory::~theory() { } + smt_params const& theory::get_fparams() const { + return ctx.get_fparams(); + } void theory::log_axiom_instantiation(literal_vector const& ls) { ast_manager& m = get_manager(); expr_ref_vector fmls(m); expr_ref tmp(m); for (literal l : ls) { - get_context().literal2expr(l, tmp); + ctx.literal2expr(l, tmp); fmls.push_back(tmp); } log_axiom_instantiation(mk_or(fmls)); @@ -196,8 +187,8 @@ namespace smt { enode *orig = std::get<0>(n); enode *substituted = std::get<1>(n); if (orig != nullptr) { - quantifier_manager::log_justification_to_root(out, orig, already_visited, get_context(), get_manager()); - quantifier_manager::log_justification_to_root(out, substituted, already_visited, get_context(), get_manager()); + quantifier_manager::log_justification_to_root(out, orig, already_visited, ctx, get_manager()); + quantifier_manager::log_justification_to_root(out, substituted, already_visited, ctx, get_manager()); } } out << "[new-match] " << static_cast(nullptr) << " " << family_name << "#" << axiom_id << " " << family_name << "#" << pattern_id; @@ -221,7 +212,7 @@ namespace smt { } theory_var theory::get_th_var(expr* e) const { - return get_th_var(get_context().get_enode(e)); + return get_th_var(ctx.get_enode(e)); } }; diff --git a/src/smt/smt_theory.h b/src/smt/smt_theory.h index 1b310d03a..c9a21c115 100644 --- a/src/smt/smt_theory.h +++ b/src/smt/smt_theory.h @@ -30,16 +30,16 @@ namespace smt { class model_value_proc; class theory { + protected: theory_id m_id; - context * m_context; - ast_manager * m_manager; + context & ctx; + ast_manager & m; enode_vector m_var2enode; unsigned_vector m_var2enode_lim; friend class context; friend class arith_value; protected: - virtual void init(context * ctx); /* --------------------------------------------------- @@ -351,11 +351,12 @@ namespace smt { public: - theory(family_id fid); + theory(context& ctx, family_id fid); virtual ~theory(); - virtual void setup() { - } + virtual void setup() {} + + virtual void init() {} theory_id get_id() const { return m_id; @@ -366,17 +367,15 @@ namespace smt { } context & get_context() const { - SASSERT(m_context); - return *m_context; + return ctx; } - - context & ctx() const { return get_context(); } ast_manager & get_manager() const { - SASSERT(m_manager); - return *m_manager; + return m; } + smt_params const& get_fparams() const; + enode * get_enode(theory_var v) const { SASSERT(v < static_cast(m_var2enode.size())); return m_var2enode[v]; @@ -453,7 +452,7 @@ namespace smt { void log_axiom_unit(app* r) { log_axiom_instantiation(r); - m_manager->trace_stream() << "[end-of-instance]\n"; + m.trace_stream() << "[end-of-instance]\n"; } public: diff --git a/src/smt/theory_arith.h b/src/smt/theory_arith.h index 78ca6b726..a8e7c58b1 100644 --- a/src/smt/theory_arith.h +++ b/src/smt/theory_arith.h @@ -1059,7 +1059,7 @@ namespace smt { // // ----------------------------------- public: - theory_arith(ast_manager & m, theory_arith_params & params); + theory_arith(context& ctx); ~theory_arith() override; theory * mk_fresh(context * new_ctx) override; diff --git a/src/smt/theory_arith_aux.h b/src/smt/theory_arith_aux.h index 202d85c23..a9cf2ba03 100644 --- a/src/smt/theory_arith_aux.h +++ b/src/smt/theory_arith_aux.h @@ -419,7 +419,7 @@ namespace smt { literal l(get_bool_var(), !m_is_true); // out << "v" << bound::get_var() << " " << bound::get_bound_kind() << " " << get_k() << " "; // out << l << ":"; - th.get_context().display_detailed_literal(out, l); + th.ctx.display_detailed_literal(out, l); } // ----------------------------------- @@ -766,7 +766,7 @@ namespace smt { << "#" << b->get_owner_id() << " " << mk_pp(b->get_owner(), m) << "\n"; } for (literal l : m_lits) { - out << l << ":"; th.get_context().display_detailed_literal(out, l) << "\n"; + out << l << ":"; th.ctx.display_detailed_literal(out, l) << "\n"; } } @@ -964,7 +964,6 @@ namespace smt { template bool theory_arith::is_safe_to_leave(theory_var x, bool inc, bool& has_int, bool& shared) { - context& ctx = get_context(); shared |= ctx.is_shared(get_enode(x)); column & c = m_columns[x]; typename svector::iterator it = c.begin_entries(); @@ -1023,7 +1022,6 @@ namespace smt { return false; } else { - context & ctx = get_context(); SASSERT(ctx.e_internalized(n)); enode * e = ctx.get_enode(n); if (is_attached_to_var(e)) { @@ -1059,7 +1057,7 @@ namespace smt { template inf_eps_rational theory_arith::maximize(theory_var v, expr_ref& blocker, bool& has_shared) { TRACE("bound_bug", display_var(tout, v); display(tout);); - if (get_context().get_fparams().m_threads > 1) + if (ctx.get_fparams().m_threads > 1) throw default_exception("multi-threaded optimization is not supported"); has_shared = false; if (!m_nl_monomials.empty()) { @@ -1126,7 +1124,6 @@ namespace smt { template expr_ref theory_arith::mk_ge(generic_model_converter& fm, theory_var v, inf_numeral const& val) { ast_manager& m = get_manager(); - context& ctx = get_context(); std::ostringstream strm; strm << val << " <= " << mk_pp(get_enode(v)->get_owner(), get_manager()); app* b = m.mk_const(symbol(strm.str().c_str()), m.mk_bool_sort()); @@ -1158,7 +1155,6 @@ namespace smt { m_params.m_arith_bound_prop = BP_NONE; SASSERT(propagation_mode() == BP_NONE); // bound propagation rules are not (yet) handled. if (bound) { - context& ctx = get_context(); m_bound_watch = ctx.get_bool_var(bound); } else { @@ -1189,7 +1185,6 @@ namespace smt { unsigned num_eqs, enode_pair const * eqs, unsigned num_params, parameter* params) { ast_manager& m = get_manager(); - context& ctx = get_context(); expr_ref tmp(m), vq(m); expr* x, *y, *e; if (null_bool_var == m_bound_watch) { @@ -1332,7 +1327,6 @@ namespace smt { bool& has_shared, // determine if pivot involves shared variable theory_var& x_i) { // base variable to pivot with x_j - context& ctx = get_context(); x_i = null_theory_var; init_gains(x_j, inc, min_gain, max_gain); has_shared |= ctx.is_shared(get_enode(x_j)); @@ -1517,7 +1511,6 @@ namespace smt { template bool theory_arith::has_interface_equality(theory_var x) { theory_var num = get_num_vars(); - context& ctx = get_context(); enode* r = get_enode(x)->get_root(); for (theory_var v = 0; v < num; v++) { if (v == x) continue; @@ -1543,7 +1536,6 @@ namespace smt { m_stats.m_max_min++; unsigned best_efforts = 0; bool inc = false; - context& ctx = get_context(); SASSERT(!maintain_integrality || valid_assignment()); @@ -1764,7 +1756,7 @@ namespace smt { theory_var s = r.get_base_var(); numeral const & coeff = r[it->m_row_idx].m_coeff; update_gains(inc, s, coeff, min_gain, max_gain); - has_shared |= get_context().is_shared(get_enode(s)); + has_shared |= ctx.is_shared(get_enode(s)); } bool result = false; if (safe_gain(min_gain, max_gain)) { @@ -2185,7 +2177,7 @@ namespace smt { enode * r = n->get_root(); enode_vector::const_iterator it = r->begin_parents(); enode_vector::const_iterator end = r->end_parents(); - TRACE("shared", tout << get_context().get_scope_level() << " " << v << " " << r->get_num_parents() << "\n";); + TRACE("shared", tout << ctx.get_scope_level() << " " << v << " " << r->get_num_parents() << "\n";); for (; it != end; ++it) { enode * parent = *it; app * o = parent->get_owner(); @@ -2237,7 +2229,7 @@ namespace smt { } if (result) - get_context().push_trail(restore_size_trail, false>(m_assume_eq_candidates, old_sz)); + ctx.push_trail(restore_size_trail, false>(m_assume_eq_candidates, old_sz)); return delayed_assume_eqs(); } @@ -2246,7 +2238,7 @@ namespace smt { if (m_assume_eq_head == m_assume_eq_candidates.size()) return false; - get_context().push_trail(value_trail(m_assume_eq_head)); + ctx.push_trail(value_trail(m_assume_eq_head)); while (m_assume_eq_head < m_assume_eq_candidates.size()) { std::pair const & p = m_assume_eq_candidates[m_assume_eq_head]; theory_var v1 = p.first; diff --git a/src/smt/theory_arith_core.h b/src/smt/theory_arith_core.h index 23e11fb1e..7d4b16e53 100644 --- a/src/smt/theory_arith_core.h +++ b/src/smt/theory_arith_core.h @@ -31,19 +31,18 @@ namespace smt { template void theory_arith::found_unsupported_op(app * n) { if (!m_found_unsupported_op) { - TRACE("arith", tout << "found non supported expression:\n" << mk_pp(n, get_manager()) << "\n";); - get_context().push_trail(value_trail(m_found_unsupported_op)); + TRACE("arith", tout << "found non supported expression:\n" << mk_pp(n, m) << "\n";); + ctx.push_trail(value_trail(m_found_unsupported_op)); m_found_unsupported_op = true; } } template void theory_arith::found_underspecified_op(app * n) { - context& ctx = get_context(); m_underspecified_ops.push_back(n); ctx.push_trail(push_back_vector>(m_underspecified_ops)); if (!m_found_underspecified_op) { - TRACE("arith", tout << "found underspecified expression:\n" << mk_pp(n, get_manager()) << "\n";); + TRACE("arith", tout << "found underspecified expression:\n" << mk_pp(n, m) << "\n";); ctx.push_trail(value_trail(m_found_underspecified_op)); m_found_underspecified_op = true; } @@ -76,7 +75,7 @@ namespace smt { bool theory_arith::process_atoms() const { if (!adaptive()) return true; - unsigned total_conflicts = get_context().get_num_conflicts(); + unsigned total_conflicts = ctx.get_num_conflicts(); if (total_conflicts < 10) return true; double f = static_cast(get_num_conflicts())/static_cast(total_conflicts); @@ -106,7 +105,7 @@ namespace smt { SASSERT(r == static_cast(m_columns.size())); SASSERT(check_vector_sizes()); bool is_int = is_int_expr(n->get_owner()); - TRACE("mk_arith_var", tout << mk_pp(n->get_owner(), get_manager()) << " is_int: " << is_int << "\n";); + TRACE("mk_arith_var", tout << mk_pp(n->get_owner(), m) << " is_int: " << is_int << "\n";); m_columns .push_back(column()); m_data .push_back(var_data(is_int)); if (random_initial_value()) { @@ -134,9 +133,9 @@ namespace smt { SASSERT(check_vector_sizes()); SASSERT(m_var_occs[r].empty()); TRACE("mk_arith_var", - tout << "#" << n->get_owner_id() << " :=\n" << mk_ll_pp(n->get_owner(), get_manager()) << "\n"; + tout << "#" << n->get_owner_id() << " :=\n" << mk_ll_pp(n->get_owner(), m) << "\n"; tout << "is_attached_to_var: " << is_attached_to_var(n) << ", var: " << n->get_th_var(get_id()) << "\n";); - get_context().attach_th_var(n, this, r); + ctx.attach_th_var(n, this, r); SASSERT(m_var_occs.back().empty()); return r; } @@ -183,7 +182,6 @@ namespace smt { */ template enode * theory_arith::mk_enode(app * n) { - context & ctx = get_context(); if (ctx.e_internalized(n)) return ctx.get_enode(n); else @@ -267,7 +265,6 @@ namespace smt { */ template void theory_arith::internalize_internal_monomial(app * m, unsigned r_id) { - context & ctx = get_context(); if (ctx.e_internalized(m)) { enode * e = ctx.get_enode(m); if (is_attached_to_var(e)) { @@ -312,15 +309,15 @@ namespace smt { */ template theory_var theory_arith::internalize_add(app * n) { - TRACE("add_bug", tout << "n: " << mk_pp(n, get_manager()) << "\n";); - CTRACE("internalize_add_bug", n->get_num_args() == 2 && n->get_arg(0) == n->get_arg(1), tout << "n: " << mk_pp(n, get_manager()) << "\n";); + TRACE("add_bug", tout << "n: " << mk_pp(n, m) << "\n";); + CTRACE("internalize_add_bug", n->get_num_args() == 2 && n->get_arg(0) == n->get_arg(1), tout << "n: " << mk_pp(n, m) << "\n";); SASSERT(m_util.is_add(n)); unsigned r_id = mk_row(); scoped_row_vars _sc(m_row_vars, m_row_vars_top); for (expr* arg : *n) { if (is_var(arg)) { std::ostringstream strm; - strm << mk_pp(n, get_manager()) << " contains a free variable"; + strm << mk_pp(n, m) << " contains a free variable"; throw default_exception(strm.str()); } internalize_internal_monomial(to_app(arg), r_id); @@ -348,17 +345,17 @@ namespace smt { \brief Internalize a term (* x y z) that does not contain a coefficient (numeral). */ template - theory_var theory_arith::internalize_mul_core(app * m) { - TRACE("internalize_mul_core", tout << "internalizing...\n" << mk_pp(m, get_manager()) << "\n";); - if (!m_util.is_mul(m)) - return internalize_term_core(m); - for (expr* arg : *m) { + theory_var theory_arith::internalize_mul_core(app * t) { + TRACE("internalize_mul_core", tout << "internalizing...\n" << mk_pp(t, m) << "\n";); + if (!m_util.is_mul(t)) + return internalize_term_core(t); + for (expr* arg : *t) { theory_var v = internalize_term_core(to_app(arg)); if (v == null_theory_var) { mk_var(mk_enode(to_app(arg))); } } - enode * e = mk_enode(m); + enode * e = mk_enode(t); theory_var v = e->get_th_var(get_id()); if (v == null_theory_var) { v = mk_var(e); @@ -410,7 +407,6 @@ namespace smt { template theory_var theory_arith::mk_binary_op(app * n) { SASSERT(n->get_num_args() == 2); - context & ctx = get_context(); if (ctx.e_internalized(n)) return expr2var(n); ctx.internalize(n->get_arg(0), false); @@ -423,7 +419,6 @@ namespace smt { theory_var theory_arith::internalize_div(app * n) { rational r(1); theory_var s = mk_binary_op(n); - context & ctx = get_context(); if (!m_util.is_numeral(n->get_arg(1), r) || r.is_zero()) found_underspecified_op(n); if (!ctx.relevancy()) mk_div_axiom(n->get_arg(0), n->get_arg(1)); @@ -434,7 +429,6 @@ namespace smt { theory_var theory_arith::internalize_idiv(app * n) { rational r; theory_var s = mk_binary_op(n); - context & ctx = get_context(); if (!m_util.is_numeral(n->get_arg(1), r) || r.is_zero()) found_underspecified_op(n); app * mod = m_util.mk_mod(n->get_arg(0), n->get_arg(1)); ctx.internalize(mod, false); @@ -445,10 +439,9 @@ namespace smt { template theory_var theory_arith::internalize_mod(app * n) { - TRACE("arith_mod", tout << "internalizing...\n" << mk_pp(n, get_manager()) << "\n";); + TRACE("arith_mod", tout << "internalizing...\n" << mk_pp(n, m) << "\n";); rational r(1); theory_var s = mk_binary_op(n); - context & ctx = get_context(); if (!m_util.is_numeral(n->get_arg(1), r) || r.is_zero()) found_underspecified_op(n); if (!ctx.relevancy()) mk_idiv_mod_axioms(n->get_arg(0), n->get_arg(1)); @@ -459,7 +452,6 @@ namespace smt { theory_var theory_arith::internalize_rem(app * n) { rational r(1); theory_var s = mk_binary_op(n); - context & ctx = get_context(); if (!m_util.is_numeral(n->get_arg(1), r) || r.is_zero()) found_underspecified_op(n); if (!ctx.relevancy()) { mk_rem_axiom(n->get_arg(0), n->get_arg(1)); @@ -469,8 +461,6 @@ namespace smt { template void theory_arith::mk_axiom(expr * ante, expr * conseq, bool simplify_conseq) { - ast_manager & m = get_manager(); - context & ctx = get_context(); th_rewriter & s = ctx.get_rewriter(); expr_ref s_ante(m), s_conseq(m); expr* s_conseq_n, * s_ante_n; @@ -526,7 +516,6 @@ namespace smt { template void theory_arith::mk_div_axiom(expr * p, expr * q) { if (!m_util.is_zero(q)) { - ast_manager & m = get_manager(); expr_ref div(m), zero(m), eqz(m), eq(m); TRACE("div_axiom_bug", tout << "expanding div_axiom for: " << mk_pp(p, m) << " / " << mk_pp(q, m) << "\n";); div = m_util.mk_div(p, q); @@ -540,9 +529,8 @@ namespace smt { template void theory_arith::mk_idiv_mod_axioms(expr * dividend, expr * divisor) { - th_rewriter & s = get_context().get_rewriter(); + th_rewriter & s = ctx.get_rewriter(); if (!m_util.is_zero(divisor)) { - ast_manager & m = get_manager(); // if divisor is zero, then idiv and mod are uninterpreted functions. expr_ref div(m), mod(m), zero(m), abs_divisor(m), one(m); expr_ref eqz(m), eq(m), lower(m), upper(m); @@ -565,7 +553,6 @@ namespace smt { mk_axiom(eqz, lower, false); mk_axiom(eqz, upper, !m_util.is_numeral(abs_divisor)); rational k; - context& ctx = get_context(); if (!m_util.is_numeral(divisor)) { // (=> (> y 0) (<= (* y (div x y)) x)) @@ -577,7 +564,6 @@ namespace smt { mk_axiom(div_non_pos, div_ge, false); } - (void)ctx; if (m_params.m_arith_enum_const_mod && m_util.is_numeral(divisor, k) && k.is_pos() && k < rational(8)) { rational j(0); @@ -601,7 +587,6 @@ namespace smt { template void theory_arith::mk_rem_axiom(expr * dividend, expr * divisor) { // if divisor is zero, then rem is an uninterpreted function. - ast_manager & m = get_manager(); expr * zero = m_util.mk_numeral(rational(0), true); expr * rem = m_util.mk_rem(dividend, divisor); expr * mod = m_util.mk_mod(dividend, divisor); @@ -623,7 +608,6 @@ namespace smt { template void theory_arith::mk_to_int_axiom(app * n) { SASSERT(m_util.is_to_int(n)); - ast_manager & m = get_manager(); expr* x = n->get_arg(0); // to_int (to_real x) = x @@ -645,7 +629,6 @@ namespace smt { template theory_var theory_arith::internalize_to_int(app * n) { SASSERT(n->get_num_args() == 1); - context & ctx = get_context(); if (ctx.e_internalized(n)) return expr2var(n); /* theory_var arg = */ internalize_term_core(to_app(n->get_arg(0))); @@ -663,7 +646,6 @@ namespace smt { template void theory_arith::mk_is_int_axiom(app * n) { SASSERT(m_util.is_is_int(n)); - ast_manager & m = get_manager(); expr* x = n->get_arg(0); expr* eq = m.mk_eq(m_util.mk_to_real(m_util.mk_to_int(x)), x); mk_axiom(m.mk_not(n), eq); @@ -673,7 +655,6 @@ namespace smt { template void theory_arith::internalize_is_int(app * n) { SASSERT(n->get_num_args() == 1); - context & ctx = get_context(); if (ctx.b_internalized(n)) return; /* theory_var arg = */ internalize_term_core(to_app(n->get_arg(0))); @@ -688,10 +669,9 @@ namespace smt { template theory_var theory_arith::internalize_to_real(app * n) { SASSERT(n->get_num_args() == 1); - context & ctx = get_context(); if (ctx.e_internalized(n)) return expr2var(n); - TRACE("to_real_bug", tout << "to-real\n" << mk_ismt2_pp(n, get_manager()) << "\n";); + TRACE("to_real_bug", tout << "to-real\n" << mk_ismt2_pp(n, m) << "\n";); theory_var arg = internalize_term_core(to_app(n->get_arg(0))); // n may be internalized by the call above if n is of the form (to_real (to_int t)) // The internalizer for (to_int t) will create (to_real (to_int t)) and internalize it. @@ -720,7 +700,6 @@ namespace smt { template theory_var theory_arith::internalize_numeral(app * n, numeral const& val) { - context& ctx = get_context(); if (ctx.e_internalized(n)) { return mk_var(ctx.get_enode(n)); } @@ -764,8 +743,7 @@ namespace smt { */ template theory_var theory_arith::internalize_term_core(app * n) { - TRACE("arith_internalize_detail", tout << "internalize_term_core:\n" << mk_pp(n, get_manager()) << "\n";); - context & ctx = get_context(); + TRACE("arith_internalize_detail", tout << "internalize_term_core:\n" << mk_pp(n, m) << "\n";); if (ctx.e_internalized(n)) { enode * e = ctx.get_enode(n); if (is_attached_to_var(e)) @@ -816,10 +794,10 @@ namespace smt { return mk_var(mk_enode(n)); } - TRACE("arith_internalize_detail", tout << "before:\n" << mk_pp(n, get_manager()) << "\n";); + TRACE("arith_internalize_detail", tout << "before:\n" << mk_pp(n, m) << "\n";); if (!ctx.e_internalized(n)) ctx.internalize(n, false); - TRACE("arith_internalize_detail", tout << "after:\n" << mk_pp(n, get_manager()) << "\n";); + TRACE("arith_internalize_detail", tout << "after:\n" << mk_pp(n, m) << "\n";); enode * e = ctx.get_enode(n); if (!is_attached_to_var(e)) return mk_var(e); @@ -985,14 +963,14 @@ namespace smt { template void theory_arith::mk_clause(literal l1, literal l2, unsigned num_params, parameter * params) { - TRACE("arith", literal lits[2]; lits[0] = l1; lits[1] = l2; get_context().display_literals_verbose(tout, 2, lits); tout << "\n";); - get_context().mk_th_axiom(get_id(), l1, l2, num_params, params); + TRACE("arith", literal lits[2]; lits[0] = l1; lits[1] = l2; ctx.display_literals_verbose(tout, 2, lits); tout << "\n";); + ctx.mk_th_axiom(get_id(), l1, l2, num_params, params); } template void theory_arith::mk_clause(literal l1, literal l2, literal l3, unsigned num_params, parameter * params) { - TRACE("arith", literal lits[3]; lits[0] = l1; lits[1] = l2; lits[2] = l3; get_context().display_literals_verbose(tout, 3, lits); tout << "\n";); - get_context().mk_th_axiom(get_id(), l1, l2, l3, num_params, params); + TRACE("arith", literal lits[3]; lits[0] = l1; lits[1] = l2; lits[2] = l3; ctx.display_literals_verbose(tout, 3, lits); tout << "\n";); + ctx.mk_th_axiom(get_id(), l1, l2, l3, num_params, params); } template @@ -1000,7 +978,7 @@ namespace smt { theory_var v = a1->get_var(); atoms & occs = m_var_occs[v]; TRACE("mk_bound_axioms", tout << "add bound axioms for v" << v << " " << a1 << "\n";); - if (!get_context().is_searching()) { + if (!ctx.is_searching()) { // // NB. We make an assumption that user push calls propagation // before internal scopes are pushed. This flushes all newly @@ -1247,8 +1225,7 @@ namespace smt { template bool theory_arith::internalize_atom(app * n, bool gate_ctx) { - TRACE("arith_internalize", tout << "internalizing atom:\n" << mk_pp(n, this->get_manager()) << "\n";); - context & ctx = get_context(); + TRACE("arith_internalize", tout << "internalizing atom:\n" << mk_pp(n, m) << "\n";); SASSERT(m_util.is_le(n) || m_util.is_ge(n) || m_util.is_is_int(n)); SASSERT(!ctx.b_internalized(n)); atom_kind kind; @@ -1313,7 +1290,7 @@ namespace smt { template bool theory_arith::internalize_term(app * term) { - TRACE("arith_internalize", tout << "internalising term:\n" << mk_pp(term, this->get_manager()) << "\n";); + TRACE("arith_internalize", tout << "internalising term:\n" << mk_pp(term, m) << "\n";); theory_var v = internalize_term_core(term); TRACE("arith_internalize", tout << "theory_var: " << v << "\n";); return v != null_theory_var; @@ -1322,8 +1299,7 @@ namespace smt { template void theory_arith::internalize_eq_eh(app * atom, bool_var v) { expr* _lhs = nullptr, *_rhs = nullptr; - if (m_params.m_arith_eager_eq_axioms && get_manager().is_eq(atom, _lhs, _rhs) && is_app(_lhs) && is_app(_rhs)) { - context & ctx = get_context(); + if (m_params.m_arith_eager_eq_axioms && m.is_eq(atom, _lhs, _rhs) && is_app(_lhs) && is_app(_rhs)) { app * lhs = to_app(_lhs); app * rhs = to_app(_rhs); enode * n1 = ctx.get_enode(lhs); @@ -1334,7 +1310,7 @@ namespace smt { if (n1->get_th_var(get_id()) != null_theory_var && n2->get_th_var(get_id()) != null_theory_var && n1 != n2) { - TRACE("mk_axioms_bug", tout << mk_bounded_pp(atom, get_manager(), 5) << "\n";); + TRACE("mk_axioms_bug", tout << mk_bounded_pp(atom, m, 5) << "\n";); m_arith_eq_adapter.mk_axioms(n1, n2); } } @@ -1350,15 +1326,15 @@ namespace smt { TRACE("arith_verbose", tout << "p" << v << " := " << (is_true?"true":"false") << "\n";); atom * a = get_bv2a(v); if (!a) return; - SASSERT(get_context().get_assignment(a->get_bool_var()) != l_undef); - SASSERT((get_context().get_assignment(a->get_bool_var()) == l_true) == is_true); + SASSERT(ctx.get_assignment(a->get_bool_var()) != l_undef); + SASSERT((ctx.get_assignment(a->get_bool_var()) == l_true) == is_true); a->assign_eh(is_true, get_epsilon(a->get_var())); m_asserted_bounds.push_back(a); } template void theory_arith::relevant_eh(app * n) { - TRACE("arith_relevant_eh", tout << "relevant_eh: " << mk_pp(n, get_manager()) << "\n";); + TRACE("arith_relevant_eh", tout << "relevant_eh: " << mk_pp(n, m) << "\n";); if (m_util.is_mod(n)) mk_idiv_mod_axioms(n->get_arg(0), n->get_arg(1)); else if (m_util.is_rem(n)) @@ -1374,8 +1350,8 @@ namespace smt { template void theory_arith::new_eq_eh(theory_var v1, theory_var v2) { TRACE("arith_new_eq_eh", tout << "#" << get_enode(v1)->get_owner_id() << " = #" << get_enode(v2)->get_owner_id() << "\n";); - TRACE("arith_new_eq_eh_detail", tout << mk_pp(get_enode(v1)->get_owner(), get_manager()) << "\n" << - mk_pp(get_enode(v2)->get_owner(), get_manager()) << "\n";); + TRACE("arith_new_eq_eh_detail", tout << mk_pp(get_enode(v1)->get_owner(), m) << "\n" << + mk_pp(get_enode(v2)->get_owner(), m) << "\n";); enode * n1 = get_enode(v1); @@ -1401,10 +1377,9 @@ namespace smt { else { if (n1->get_owner_id() > n2->get_owner_id()) std::swap(n1, n2); - sort * st = get_manager().get_sort(n1->get_owner()); + sort * st = m.get_sort(n1->get_owner()); app * minus_one = m_util.mk_numeral(rational::minus_one(), st); app * s = m_util.mk_add(n1->get_owner(), m_util.mk_mul(minus_one, n2->get_owner())); - context & ctx = get_context(); ctx.internalize(s, false); enode * e_s = ctx.get_enode(s); ctx.mark_as_relevant(e_s); @@ -1430,8 +1405,8 @@ namespace smt { template void theory_arith::new_diseq_eh(theory_var v1, theory_var v2) { - TRACE("arith_new_diseq_eh", tout << mk_bounded_pp(get_enode(v1)->get_owner(), get_manager()) << "\n" << - mk_bounded_pp(get_enode(v2)->get_owner(), get_manager()) << "\n";); + TRACE("arith_new_diseq_eh", tout << mk_bounded_pp(get_enode(v1)->get_owner(), m) << "\n" << + mk_bounded_pp(get_enode(v2)->get_owner(), m) << "\n";); m_stats.m_assert_diseq++; m_arith_eq_adapter.new_diseq_eh(v1, v2); } @@ -1463,7 +1438,7 @@ namespace smt { final_check_status result = FC_DONE; final_check_status ok; do { - if (get_context().get_cancel_flag()) { + if (ctx.get_cancel_flag()) { return FC_GIVEUP; } @@ -1497,7 +1472,7 @@ namespace smt { case FC_CONTINUE: TRACE("arith", tout << "continue arith..." - << (get_context().inconsistent()?"inconsistent\n":"\n");); + << (ctx.inconsistent()?"inconsistent\n":"\n");); return FC_CONTINUE; } } @@ -1518,7 +1493,7 @@ namespace smt { return FC_CONTINUE; if (delayed_assume_eqs()) return FC_CONTINUE; - get_context().push_trail(value_trail(m_final_check_idx)); + ctx.push_trail(value_trail(m_final_check_idx)); m_liberal_final_check = true; m_changed_assignment = false; final_check_status result = final_check_core(); @@ -1566,7 +1541,7 @@ namespace smt { failed(); return false; } - if (get_context().get_cancel_flag()) { + if (ctx.get_cancel_flag()) { return true; } CASSERT("arith", satisfy_bounds()); @@ -1698,19 +1673,19 @@ namespace smt { } template - theory_arith::theory_arith(ast_manager & m, theory_arith_params & params): - theory(m.mk_family_id("arith")), - m_params(params), + theory_arith::theory_arith(context& ctx): + theory(ctx, ctx.get_manager().mk_family_id("arith")), + m_params(ctx.get_fparams()), m_util(m), m_arith_eq_solver(m), m_found_unsupported_op(false), m_found_underspecified_op(false), - m_arith_eq_adapter(*this, params, m_util), + m_arith_eq_adapter(*this, m_util), m_asserted_qhead(0), m_row_vars_top(0), m_to_patch(1024), m_blands_rule(false), - m_random(params.m_arith_random_seed), + m_random(ctx.get_fparams().m_arith_random_seed), m_num_conflicts(0), m_branch_cut_counter(0), m_eager_gcd(m_params.m_arith_eager_gcd), @@ -1733,7 +1708,7 @@ namespace smt { template theory* theory_arith::mk_fresh(context* new_ctx) { - return alloc(theory_arith, new_ctx->get_manager(), new_ctx->get_fparams()); + return alloc(theory_arith, *new_ctx); } template @@ -1846,7 +1821,7 @@ namespace smt { SASSERT(!is_non_base(v)); add_row(r1, c, get_var_row(v), false); } - get_manager().limit().inc(sz); + m.limit().inc(sz); } // ----------------------------------- @@ -1899,7 +1874,7 @@ namespace smt { if (is_base(v) && !m_to_patch.contains(v) && (below_lower(v) || above_upper(v))) { m_to_patch.insert(v); } - get_manager().limit().inc(); + m.limit().inc(); } /** @@ -1974,7 +1949,7 @@ namespace smt { DIVIDE_ROW(it->m_coeff /= tmp); } - get_manager().limit().inc(r.size()); + m.limit().inc(r.size()); set_var_row(x_i, -1); set_var_row(x_j, r_id); @@ -2028,7 +2003,7 @@ namespace smt { a_kj = r2[it->m_row_idx].m_coeff; a_kj.neg(); add_row(it->m_row_id, a_kj, r_id, apply_gcd_test); - get_manager().limit().inc((r1_sz + r2.size()) * (a_kj.storage_size())); + m.limit().inc((r1_sz + r2.size()) * (a_kj.storage_size())); } } else { @@ -2210,7 +2185,7 @@ namespace smt { template theory_var theory_arith::select_pivot(theory_var x_i, bool is_below, numeral & out_a_ij) { TRACE("select_pivot", tout << "m_blands_rule: " << m_blands_rule << " v" << x_i << "\n";); - CTRACE("select_pivot_info", x_i > 500, get_context().display(tout);); + CTRACE("select_pivot_info", x_i > 500, ctx.display(tout);); if (m_blands_rule) return select_blands_pivot_core(x_i, is_below, out_a_ij); else if (is_below) @@ -2352,7 +2327,7 @@ namespace smt { return false; } TRACE("arith_make_feasible_detail", display(tout);); - if (get_context().get_cancel_flag()) { + if (ctx.get_cancel_flag()) { return true; } } @@ -2794,7 +2769,6 @@ namespace smt { if (!relax_bounds() && (!ante.lits().empty() || !ante.eqs().empty())) { return; } - context & ctx = get_context(); row_entry const & entry = r[idx]; numeral coeff = entry.m_coeff; if (relax_bounds()) { @@ -2903,7 +2877,7 @@ namespace smt { for (atom* a : as) { bool_var bv = a->get_bool_var(); literal l(bv); - if (get_context().get_assignment(bv) == l_undef) { + if (ctx.get_assignment(bv) == l_undef) { inf_numeral const & k2 = a->get_k(); delta.reset(); if (a->get_atom_kind() == A_LOWER) { @@ -2966,7 +2940,6 @@ namespace smt { template void theory_arith::dump_lemmas(literal l, antecedents const& ante) { - context & ctx = get_context(); if (dump_lemmas()) { TRACE("arith", ante.display(tout) << " --> "; ctx.display_detailed_literal(tout, l); tout << "\n";); ctx.display_lemma_as_smt_problem(ante.lits().size(), ante.lits().c_ptr(), @@ -2977,7 +2950,6 @@ namespace smt { template void theory_arith::dump_lemmas(literal l, derived_bound const& ante) { - context & ctx = get_context(); if (dump_lemmas()) { ctx.display_lemma_as_smt_problem(ante.lits().size(), ante.lits().c_ptr(), ante.eqs().size(), ante.eqs().c_ptr(), l); @@ -2987,7 +2959,6 @@ namespace smt { template void theory_arith::assign_bound_literal(literal l, row const & r, unsigned idx, bool is_lower, inf_numeral & delta) { m_stats.m_bound_props++; - context & ctx = get_context(); antecedents ante(*this); explain_bound(r, idx, is_lower, delta, ante); @@ -3091,7 +3062,6 @@ namespace smt { void theory_arith::set_conflict(unsigned num_literals, literal const * lits, unsigned num_eqs, enode_pair const * eqs, antecedents& bounds, char const* proof_rule) { SASSERT(num_literals != 0 || num_eqs != 0); - context & ctx = get_context(); m_stats.m_conflicts++; m_num_conflicts++; TRACE("arith_conflict", @@ -3230,7 +3200,7 @@ namespace smt { for (theory_var v = 0; v < num; v++) { if (is_int_src(v)) continue; - if (!get_context().is_shared(get_enode(v))) + if (!ctx.is_shared(get_enode(v))) continue; inf_numeral const & val = get_value(v); if (Ext::is_infinite(val)) { @@ -3263,13 +3233,13 @@ namespace smt { } template - void theory_arith::init_model(model_generator & m) { + void theory_arith::init_model(model_generator & mg) { TRACE("theory_arith", tout << "init model invoked...\n"; for (app* n : m_underspecified_ops) { - tout << mk_pp(n, get_manager()) << "\n"; + tout << mk_pp(n, m) << "\n"; }); - m_factory = alloc(arith_factory, get_manager()); - m.register_factory(m_factory); + m_factory = alloc(arith_factory, m); + mg.register_factory(m_factory); if (!m_model_depends_on_computed_epsilon) { compute_epsilon(); refine_epsilon(); diff --git a/src/smt/theory_arith_nl.h b/src/smt/theory_arith_nl.h index 5b0d14652..653e4d325 100644 --- a/src/smt/theory_arith_nl.h +++ b/src/smt/theory_arith_nl.h @@ -71,7 +71,7 @@ void theory_arith::mark_dependents(theory_var v, svector & vars expr * n = var2expr(v); SASSERT(m_util.is_mul(n)); for (expr * curr : *to_app(n)) { - if (get_context().e_internalized(curr)) { + if (ctx.e_internalized(curr)) { theory_var v = expr2var(curr); SASSERT(v != null_theory_var); mark_var(v, vars, already_found); @@ -120,7 +120,6 @@ void theory_arith::get_non_linear_cluster(svector & vars) { return; var_set already_found; row_set already_visited_rows; - context & ctx = get_context(); for (theory_var v : m_nl_monomials) { expr * n = var2expr(v); if (ctx.is_relevant(n)) @@ -539,7 +538,6 @@ template bool theory_arith::propagate_nl_bounds() { m_dep_manager.reset(); bool propagated = false; - context & ctx = get_context(); for (unsigned i = 0; i < m_nl_monomials.size(); i++) { theory_var v = m_nl_monomials[i]; expr * m = var2expr(v); @@ -626,7 +624,6 @@ bool theory_arith::check_monomial_assignment(theory_var v, bool & computed_ template bool theory_arith::check_monomial_assignments() { bool computed_epsilon = false; - context & ctx = get_context(); for (theory_var v : m_nl_monomials) { TRACE("non_linear", tout << "v" << v << " is relevant: " << ctx.is_relevant(get_enode(v)) << "\n"; tout << "check_monomial_assignments result: " << check_monomial_assignment(v, computed_epsilon) << "\n"; @@ -653,7 +650,6 @@ bool theory_arith::check_monomial_assignments() { template theory_var theory_arith::find_nl_var_for_branching() { TRACE("nl_branching", tout << "looking for variable to branch...\n"; display(tout);); - context & ctx = get_context(); theory_var target = null_theory_var; bool bounded = false; unsigned n = 0; @@ -717,7 +713,6 @@ bool theory_arith::branch_nl_int_var(theory_var v) { else bound = m_util.mk_eq(var2expr(v), m_util.mk_numeral(rational(0), true)); TRACE("non_linear", tout << "new bound:\n" << mk_pp(bound, get_manager()) << "\n";); - context & ctx = get_context(); ast_manager & m = get_manager(); { std::function fn = [&]() { return m.mk_or(bound, m.mk_not(bound)); }; @@ -739,7 +734,7 @@ bool theory_arith::is_monomial_linear(expr * m) const { SASSERT(is_pure_monomial(m)); unsigned num_nl_vars = 0; for (expr* arg : *to_app(m)) { - if (!get_context().e_internalized(arg)) + if (!ctx.e_internalized(arg)) return false; theory_var _var = expr2var(arg); CTRACE("non_linear", is_fixed(_var), @@ -811,7 +806,6 @@ bool theory_arith::propagate_linear_monomial(theory_var v) { TRACE("non_linear", tout << "new linear monomial... k: " << k << "\n";); expr * x_n = k.is_zero() ? nullptr : get_monomial_non_fixed_var(m); TRACE("non_linear_bug", if (x_n != 0) { tout << "x_n: " << mk_bounded_pp(x_n, get_manager()) << "\nx_n: #" << x_n->get_id() << "\n"; }); - context & ctx = get_context(); derived_bound * new_lower = nullptr; derived_bound * new_upper = nullptr; if (x_n != nullptr) { @@ -832,7 +826,7 @@ bool theory_arith::propagate_linear_monomial(theory_var v) { ctx.internalize(rhs, false); ctx.mark_as_relevant(rhs); } - TRACE("non_linear_bug", tout << "enode: " << get_context().get_enode(rhs) << " enode_id: " << get_context().get_enode(rhs)->get_owner_id() << "\n";); + TRACE("non_linear_bug", tout << "enode: " << ctx.get_enode(rhs) << " enode_id: " << ctx.get_enode(rhs)->get_owner_id() << "\n";); theory_var new_v = expr2var(rhs); SASSERT(new_v != null_theory_var); new_lower = alloc(derived_bound, new_v, inf_numeral(0), B_LOWER); @@ -1126,7 +1120,6 @@ void theory_arith::display_coeff_exprs(std::ostream & out, buffer bool theory_arith::get_polynomial_info(buffer const & p, sbuffer & varinfo) { - context & ctx = get_context(); varinfo.reset(); m_var2num_occs.reset(); @@ -1841,7 +1834,7 @@ void theory_arith::set_conflict(v_dependency * d) { derived_bound b(null_theory_var, inf_numeral(0), B_LOWER); dependency2new_bound(d, b); set_conflict(b, ante, "arith_nl"); - TRACE("non_linear", for (literal lit : b.m_lits) get_context().display_literal_verbose(tout, lit) << "\n"; tout << "\n";); + TRACE("non_linear", for (literal lit : b.m_lits) ctx.display_literal_verbose(tout, lit) << "\n"; tout << "\n";); } /** @@ -2107,7 +2100,6 @@ bool theory_arith::internalize_gb_eq(grobner::equation const * eq) { else args.push_back(monomial2expr(eq->get_monomial(i), is_int)); } - context & ctx = get_context(); th_rewriter& s = ctx.get_rewriter(); expr_ref pol(get_manager()); SASSERT(!args.empty()); @@ -2145,7 +2137,7 @@ void theory_arith::update_statistics(grobner & gb) { template void theory_arith::set_gb_exhausted() { IF_VERBOSE(3, verbose_stream() << "Grobner basis computation interrupted. Increase threshold using NL_ARITH_GB_THRESHOLD=\n";); - get_context().push_trail(value_trail(m_nl_gb_exhausted)); + ctx.push_trail(value_trail(m_nl_gb_exhausted)); m_nl_gb_exhausted = true; } @@ -2225,7 +2217,7 @@ bool theory_arith::scan_for_linear(ptr_vector& eqs, grob template bool theory_arith::compute_basis_loop(grobner & gb) { while (gb.get_num_new_equations() < m_params.m_nl_arith_gb_threshold) { - if (get_context().get_cancel_flag()) { + if (ctx.get_cancel_flag()) { return false; } if (gb.compute_basis_step()) @@ -2260,7 +2252,7 @@ typename theory_arith::gb_result theory_arith::compute_grobner(svector compute_basis(gb, warn); update_statistics(gb); TRACE("non_linear_gb", tout << "after:\n"; gb.display(tout);); - if (get_context().get_cancel_flag()) + if (ctx.get_cancel_flag()) return GB_FAIL; if (get_gb_eqs_and_look_for_conflict(eqs, gb)) return GB_PROGRESS; @@ -2282,7 +2274,7 @@ bool theory_arith::max_min_nl_vars() { expr * n = var2expr(v); SASSERT(is_pure_monomial(n)); for (expr * curr : *to_app(n)) { - if (get_context().e_internalized(curr)) { + if (ctx.e_internalized(curr)) { theory_var v = expr2var(curr); SASSERT(v != null_theory_var); mark_var(v, vars, already_found); @@ -2321,12 +2313,12 @@ final_check_status theory_arith::process_non_linear() { return FC_GIVEUP; } - get_context().push_trail(value_trail(m_nl_rounds)); + ctx.push_trail(value_trail(m_nl_rounds)); m_nl_rounds++; elim_quasi_base_rows(); move_non_base_vars_to_bounds(); - TRACE("non_linear_verbose", tout << "processing non linear constraints...\n"; get_context().display(tout);); + TRACE("non_linear_verbose", tout << "processing non linear constraints...\n"; ctx.display(tout);); if (!make_feasible()) { TRACE("non_linear", tout << "failed to move variables to bounds.\n";); failed(); @@ -2345,7 +2337,7 @@ final_check_status theory_arith::process_non_linear() { bool progress; unsigned old_idx = m_nl_strategy_idx; - get_context().push_trail(value_trail(m_nl_strategy_idx)); + ctx.push_trail(value_trail(m_nl_strategy_idx)); do { progress = false; diff --git a/src/smt/theory_array.cpp b/src/smt/theory_array.cpp index f36513472..92ca67aeb 100644 --- a/src/smt/theory_array.cpp +++ b/src/smt/theory_array.cpp @@ -24,12 +24,14 @@ Revision History: namespace smt { - theory_array::theory_array(ast_manager & m, theory_array_params & params): - theory_array_base(m), - m_params(params), + theory_array::theory_array(context& ctx): + theory_array_base(ctx), + m_params(ctx.get_fparams()), m_find(*this), m_trail_stack(*this), m_final_check_idx(0) { + if (!ctx.relevancy()) + m_params.m_array_laziness = 0; } theory_array::~theory_array() { @@ -37,17 +39,11 @@ namespace smt { m_var_data.reset(); } - void theory_array::init(context * ctx) { - theory_array_base::init(ctx); - if (!ctx->relevancy()) - m_params.m_array_laziness = 0; - } - void theory_array::merge_eh(theory_var v1, theory_var v2, theory_var, theory_var) { // v1 is the new root TRACE("array", tout << "merging v" << v1 << " v" << v2 << "\n"; display_var(tout, v1); - tout << mk_pp(get_enode(v1)->get_owner(), get_manager()) << " <- " << mk_pp(get_enode(v2)->get_owner(), get_manager()) << "\n";); + tout << mk_pp(get_enode(v1)->get_owner(), m) << " <- " << mk_pp(get_enode(v2)->get_owner(), m) << "\n";); SASSERT(v1 == find(v1)); var_data * d1 = m_var_data[v1]; var_data * d2 = m_var_data[v2]; @@ -67,8 +63,6 @@ namespace smt { } theory_var theory_array::mk_var(enode * n) { - ast_manager& m = get_manager(); - context& ctx = get_context(); theory_var r = theory_array_base::mk_var(n); VERIFY(r == static_cast(m_find.mk_var())); SASSERT(r == static_cast(m_var_data.size())); @@ -95,7 +89,7 @@ namespace smt { v = find(v); var_data * d = m_var_data[v]; d->m_parent_selects.push_back(s); - TRACE("array", tout << v << " " << mk_pp(s->get_owner(), get_manager()) << " " << mk_pp(get_enode(v)->get_owner(), get_manager()) << "\n";); + TRACE("array", tout << v << " " << mk_pp(s->get_owner(), m) << " " << mk_pp(get_enode(v)->get_owner(), m) << "\n";); m_trail_stack.push(push_back_trail(d->m_parent_selects)); for (enode* n : d->m_stores) { instantiate_axiom2a(s, n); @@ -202,7 +196,7 @@ namespace smt { } void theory_array::instantiate_axiom1(enode * store) { - TRACE("array", tout << "axiom 1:\n" << mk_bounded_pp(store->get_owner(), get_manager()) << "\n";); + TRACE("array", tout << "axiom 1:\n" << mk_bounded_pp(store->get_owner(), m) << "\n";); SASSERT(is_store(store)); m_stats.m_num_axiom1++; assert_store_axiom1(store); @@ -244,8 +238,7 @@ namespace smt { // Internalize the term. If it has already been internalized, return false. // bool theory_array::internalize_term_core(app * n) { - TRACE("array_bug", tout << mk_bounded_pp(n, get_manager()) << "\n";); - context & ctx = get_context(); + TRACE("array_bug", tout << mk_bounded_pp(n, m) << "\n";); unsigned num_args = n->get_num_args(); for (unsigned i = 0; i < num_args; i++) ctx.internalize(n->get_arg(i), false); @@ -256,7 +249,7 @@ namespace smt { if (!is_attached_to_var(e)) mk_var(e); - if (get_manager().is_bool(n)) { + if (m.is_bool(n)) { bool_var bv = ctx.mk_bool_var(n); ctx.set_var_theory(bv, get_id()); ctx.set_enode_flag(bv, true); @@ -270,11 +263,10 @@ namespace smt { found_unsupported_op(n); return false; } - TRACE("array_bug", tout << mk_bounded_pp(n, get_manager()) << "\n";); + TRACE("array_bug", tout << mk_bounded_pp(n, m) << "\n";); if (!internalize_term_core(n)) { return true; } - context & ctx = get_context(); enode * arg0 = ctx.get_enode(n->get_arg(0)); if (!is_attached_to_var(arg0)) mk_var(arg0); @@ -315,8 +307,8 @@ namespace smt { v2 = find(v2); var_data * d1 = m_var_data[v1]; TRACE("ext", tout << "extensionality: " << d1->m_is_array << "\n" - << mk_bounded_pp(get_enode(v1)->get_owner(), get_manager(), 5) << "\n" - << mk_bounded_pp(get_enode(v2)->get_owner(), get_manager(), 5) << "\n";); + << mk_bounded_pp(get_enode(v1)->get_owner(), m, 5) << "\n" + << mk_bounded_pp(get_enode(v2)->get_owner(), m, 5) << "\n";); if (d1->m_is_array) { SASSERT(m_var_data[v2]->m_is_array); @@ -327,12 +319,11 @@ namespace smt { void theory_array::relevant_eh(app * n) { if (m_params.m_array_laziness == 0) return; - if (get_manager().is_ite(n)) { - TRACE("array", tout << "relevant ite " << mk_pp(n, get_manager()) << "\n";); + if (m.is_ite(n)) { + TRACE("array", tout << "relevant ite " << mk_pp(n, m) << "\n";); } if (!is_store(n) && !is_select(n)) return; - context & ctx = get_context(); if (!ctx.e_internalized(n)) ctx.internalize(n, false); enode * arg = ctx.get_enode(n->get_arg(0)); theory_var v_arg = arg->get_th_var(get_id()); @@ -399,7 +390,7 @@ namespace smt { } } bool should_giveup = m_found_unsupported_op || has_propagate_up_trail(); - if (r == FC_DONE && should_giveup && !get_context().get_fparams().m_array_fake_support) + if (r == FC_DONE && should_giveup && !ctx.get_fparams().m_array_fake_support) r = FC_GIVEUP; CTRACE("array", r != FC_DONE || m_found_unsupported_op, tout << r << "\n";); return r; diff --git a/src/smt/theory_array.h b/src/smt/theory_array.h index 16ef8af0a..4ab915aa1 100644 --- a/src/smt/theory_array.h +++ b/src/smt/theory_array.h @@ -55,7 +55,6 @@ namespace smt { th_trail_stack m_trail_stack; unsigned m_final_check_idx; - void init(context * ctx) override; theory_var mk_var(enode * n) override; bool internalize_atom(app * atom, bool gate_ctx) override; bool internalize_term(app * term) override; @@ -96,10 +95,10 @@ namespace smt { static void display_ids(std::ostream & out, unsigned n, enode * const * v); public: - theory_array(ast_manager & m, theory_array_params & params); + theory_array(context& ctx); ~theory_array() override; - theory * mk_fresh(context * new_ctx) override { return alloc(theory_array, new_ctx->get_manager(), new_ctx->get_fparams()); } + theory * mk_fresh(context * new_ctx) override { return alloc(theory_array, *new_ctx); } char const * get_name() const override { return "array"; } diff --git a/src/smt/theory_array_base.cpp b/src/smt/theory_array_base.cpp index 919829e87..967b1f299 100644 --- a/src/smt/theory_array_base.cpp +++ b/src/smt/theory_array_base.cpp @@ -26,28 +26,28 @@ Revision History: namespace smt { - theory_array_base::theory_array_base(ast_manager & m): - theory(m.mk_family_id("array")), + theory_array_base::theory_array_base(context& ctx): + theory(ctx, ctx.get_manager().mk_family_id("array")), m_found_unsupported_op(false), m_array_weak_head(0) { } void theory_array_base::add_weak_var(theory_var v) { - get_context().push_trail(push_back_vector>(m_array_weak_trail)); + ctx.push_trail(push_back_vector>(m_array_weak_trail)); m_array_weak_trail.push_back(v); } void theory_array_base::found_unsupported_op(expr * n) { - if (!get_context().get_fparams().m_array_fake_support && !m_found_unsupported_op) { - TRACE("array", tout << mk_ll_pp(n, get_manager()) << "\n";); - get_context().push_trail(value_trail(m_found_unsupported_op)); + if (!ctx.get_fparams().m_array_fake_support && !m_found_unsupported_op) { + TRACE("array", tout << mk_ll_pp(n, m) << "\n";); + ctx.push_trail(value_trail(m_found_unsupported_op)); m_found_unsupported_op = true; } } app * theory_array_base::mk_select(unsigned num_args, expr * const * args) { - app * r = get_manager().mk_app(get_family_id(), OP_SELECT, 0, nullptr, num_args, args); + app * r = m.mk_app(get_family_id(), OP_SELECT, 0, nullptr, num_args, args); TRACE("mk_var_bug", tout << "mk_select: " << r->get_id() << " num_args: " << num_args; for (unsigned i = 0; i < num_args; i++) tout << " " << args[i]->get_id(); tout << "\n";); @@ -55,14 +55,14 @@ namespace smt { } app * theory_array_base::mk_store(unsigned num_args, expr * const * args) { - return get_manager().mk_app(get_family_id(), OP_STORE, 0, nullptr, num_args, args); + return m.mk_app(get_family_id(), OP_STORE, 0, nullptr, num_args, args); } app * theory_array_base::mk_default(expr * a) { - sort * s = get_manager().get_sort(a); + sort * s = m.get_sort(a); unsigned num_params = get_dimension(s); parameter const* params = s->get_info()->get_parameters(); - return get_manager().mk_app(get_family_id(), OP_ARRAY_DEFAULT, num_params, params, 1, & a); + return m.mk_app(get_family_id(), OP_ARRAY_DEFAULT, num_params, params, 1, & a); } unsigned theory_array_base::get_dimension(sort * s) const { @@ -72,14 +72,13 @@ namespace smt { } void theory_array_base::assert_axiom(unsigned num_lits, literal * lits) { - context & ctx = get_context(); TRACE("array_axiom", tout << "literals:\n"; for (unsigned i = 0; i < num_lits; ++i) { expr * e = ctx.bool_var2expr(lits[i].var()); if (lits[i].sign()) tout << "not "; - tout << mk_pp(e, get_manager()) << " "; + tout << mk_pp(e, m) << " "; tout << "\n"; }); ctx.mk_th_axiom(get_id(), num_lits, lits); @@ -97,8 +96,6 @@ namespace smt { void theory_array_base::assert_store_axiom1_core(enode * e) { app * n = e->get_owner(); SASSERT(is_store(n)); - context & ctx = get_context(); - ast_manager & m = get_manager(); ptr_buffer sel_args; unsigned num_args = n->get_num_args(); SASSERT(num_args >= 3); @@ -137,14 +134,12 @@ namespace smt { */ void theory_array_base::assert_store_axiom2_core(enode * store, enode * select) { TRACE("array", tout << "generating axiom2: #" << store->get_owner_id() << " #" << select->get_owner_id() << "\n"; - tout << mk_bounded_pp(store->get_owner(), get_manager()) << "\n" << mk_bounded_pp(select->get_owner(), get_manager()) << "\n";); + tout << mk_bounded_pp(store->get_owner(), m) << "\n" << mk_bounded_pp(select->get_owner(), m) << "\n";); SASSERT(is_store(store)); SASSERT(is_select(select)); SASSERT(store->get_num_args() == 1 + select->get_num_args()); ptr_buffer sel1_args, sel2_args; - context & ctx = get_context(); - ast_manager & m = get_manager(); enode * a = store->get_arg(0); enode * const * is = select->get_args() + 1; enode * const * js = store->get_args() + 1; @@ -211,7 +206,7 @@ namespace smt { break; if (i == num_args) return false; - if (get_context().add_fingerprint(store, store->get_owner_id(), select->get_num_args() - 1, select->get_args() + 1)) { + if (ctx.add_fingerprint(store, store->get_owner_id(), select->get_num_args() - 1, select->get_args() + 1)) { TRACE("array", tout << "adding axiom2 to todo queue\n";); m_axiom2_todo.push_back(std::make_pair(store, select)); return true; @@ -228,8 +223,7 @@ namespace smt { unsigned dimension = get_dimension(s_array); func_decl_ref_vector * ext_skolems = nullptr; if (!m_sort2skolem.find(s_array, ext_skolems)) { - array_util util(get_manager()); - ast_manager & m = get_manager(); + array_util util(m); ext_skolems = alloc(func_decl_ref_vector, m); for (unsigned i = 0; i < dimension; ++i) { func_decl * ext_sk_decl = util.mk_array_ext(s_array, i); @@ -258,7 +252,6 @@ namespace smt { v1' = v1, v2' = v2, i1 = i2, select(v1', i1) /= select(v2', i2) in the logical context. */ bool theory_array_base::already_diseq(enode * v1, enode * v2) { - context & ctx = get_context(); enode * r1 = v1->get_root(); enode * r2 = v2->get_root(); @@ -295,7 +288,6 @@ namespace smt { } bool theory_array_base::assert_extensionality(enode * n1, enode * n2) { - context & ctx = get_context(); if (n1->get_owner_id() > n2->get_owner_id()) std::swap(n1, n2); enode * nodes[2] = { n1, n2 }; @@ -311,7 +303,6 @@ namespace smt { TRACE("array", tout << "congruent: #" << a1->get_owner_id() << " #" << a2->get_owner_id() << "\n";); SASSERT(is_array_sort(a1)); SASSERT(is_array_sort(a2)); - context & ctx = get_context(); if (a1->get_owner_id() > a2->get_owner_id()) std::swap(a1, a2); enode * nodes[2] = { a1, a2 }; @@ -324,8 +315,6 @@ namespace smt { void theory_array_base::assert_extensionality_core(enode * n1, enode * n2) { app * e1 = n1->get_owner(); app * e2 = n2->get_owner(); - context & ctx = get_context(); - ast_manager & m = get_manager(); func_decl_ref_vector * funcs = nullptr; sort * s = m.get_sort(e1); @@ -364,8 +353,6 @@ namespace smt { void theory_array_base::assert_congruent_core(enode * n1, enode * n2) { app * e1 = n1->get_owner(); app * e2 = n2->get_owner(); - context & ctx = get_context(); - ast_manager & m = get_manager(); sort* s = m.get_sort(e1); unsigned dimension = get_array_arity(s); literal n1_eq_n2 = mk_eq(e1, e2, true); @@ -397,7 +384,6 @@ namespace smt { } expr_ref theory_array_base::instantiate_lambda(app* e) { - ast_manager& m = get_manager(); quantifier * q = m.is_lambda_def(e->get_decl()); expr_ref f(e, m); if (q) { @@ -426,7 +412,7 @@ namespace smt { !m_axiom2_todo.empty() || !m_extensionality_todo.empty() || !m_congruent_todo.empty() || - (!get_context().get_fparams().m_array_weak && has_propagate_up_trail()); + (!ctx.get_fparams().m_array_weak && has_propagate_up_trail()); } void theory_array_base::propagate() { @@ -443,8 +429,8 @@ namespace smt { assert_congruent_core(m_congruent_todo[i].first, m_congruent_todo[i].second); m_extensionality_todo.reset(); m_congruent_todo.reset(); - if (!get_context().get_fparams().m_array_weak && has_propagate_up_trail()) { - get_context().push_trail(value_trail(m_array_weak_head)); + if (!ctx.get_fparams().m_array_weak && has_propagate_up_trail()) { + ctx.push_trail(value_trail(m_array_weak_head)); for (; m_array_weak_head < m_array_weak_trail.size(); ++m_array_weak_head) { set_prop_upward(m_array_weak_trail[m_array_weak_head]); } @@ -502,7 +488,6 @@ namespace smt { #if 0 void theory_array_base::collect_shared_vars(sbuffer & result) { TRACE("array_shared", tout << "collecting shared vars...\n";); - context & ctx = get_context(); ptr_buffer to_unmark; unsigned num_vars = get_num_vars(); for (unsigned i = 0; i < num_vars; i++) { @@ -537,7 +522,6 @@ namespace smt { } void theory_array_base::collect_shared_vars(sbuffer & result) { - context & ctx = get_context(); ptr_buffer to_unmark; unsigned num_vars = get_num_vars(); for (unsigned i = 0; i < num_vars; i++) { @@ -571,8 +555,6 @@ namespace smt { Return the number of new interface equalities. */ unsigned theory_array_base::mk_interface_eqs() { - context & ctx = get_context(); - ast_manager & m = get_manager(); sbuffer roots; collect_shared_vars(roots); unsigned result = 0; @@ -642,7 +624,7 @@ namespace smt { void theory_array_base::set_default(theory_var v, enode* n) { - TRACE("array", tout << "set default: " << v << " " << mk_pp(n->get_owner(), get_manager()) << "\n";); + TRACE("array", tout << "set default: " << v << " " << mk_pp(n->get_owner(), m) << "\n";); v = mg_find(v); if (m_defaults[v] == 0) { m_defaults[v] = n; @@ -674,36 +656,36 @@ namespace smt { return n; } - void theory_array_base::mg_merge(theory_var n, theory_var m) { - n = mg_find(n); - m = mg_find(m); - if (n != m) { - SASSERT(m_parents[n] < 0); - SASSERT(m_parents[m] < 0); - if (m_parents[n] > m_parents[m]) { - std::swap(n, m); + void theory_array_base::mg_merge(theory_var u, theory_var v) { + u = mg_find(u); + v = mg_find(v); + if (u != v) { + SASSERT(m_parents[u] < 0); + SASSERT(m_parents[v] < 0); + if (m_parents[u] > m_parents[v]) { + std::swap(u, v); } - m_parents[n] += m_parents[m]; - m_parents[m] = n; + m_parents[u] += m_parents[v]; + m_parents[v] = u; - if (m_defaults[n] == 0) { - m_defaults[n] = m_defaults[m]; + if (m_defaults[u] == 0) { + m_defaults[u] = m_defaults[v]; } - CTRACE("array", m_defaults[m], - tout << mk_pp(m_defaults[m]->get_root()->get_owner(), get_manager()) << "\n"; - tout << mk_pp(m_defaults[n]->get_root()->get_owner(), get_manager()) << "\n"; + CTRACE("array", m_defaults[v], + tout << mk_pp(m_defaults[v]->get_root()->get_owner(), m) << "\n"; + tout << mk_pp(m_defaults[u]->get_root()->get_owner(), m) << "\n"; ); - // NB. it may be the case that m_defaults[m] != m_defaults[n] + // NB. it may be the case that m_defaults[u] != m_defaults[v] // when m and n are finite arrays. } } - void theory_array_base::init_model(model_generator & m) { - m_factory = alloc(array_factory, get_manager(), m.get_model()); - m.register_factory(m_factory); + void theory_array_base::init_model(model_generator & mg) { + m_factory = alloc(array_factory, m, mg.get_model()); + mg.register_factory(m_factory); m_use_unspecified_default = is_unspecified_default_ok(); collect_defaults(); collect_selects(); @@ -718,7 +700,6 @@ namespace smt { That is, other modules (such as smt_model_finder) may set the default value to an arbitrary value. */ bool theory_array_base::is_unspecified_default_ok() const { - context & ctx = get_context(); int num_vars = get_num_vars(); for (theory_var v = 0; v < num_vars; ++v) { enode * n = get_enode(v); @@ -746,7 +727,6 @@ namespace smt { if (m_use_unspecified_default) return; - context & ctx = get_context(); // // Create equivalence classes for defaults. @@ -768,7 +748,7 @@ namespace smt { mg_merge(v, get_representative(w)); - TRACE("array", tout << "merge: " << mk_pp(n->get_owner(), get_manager()) << " " << v << " " << w << "\n";); + TRACE("array", tout << "merge: " << mk_pp(n->get_owner(), m) << " " << v << " " << w << "\n";); } else if (is_const(n)) { set_default(v, n->get_arg(0)); @@ -817,10 +797,10 @@ namespace smt { for (theory_var v = 0; v < num_vars; ++v) { enode * r = get_enode(v)->get_root(); - if (is_representative(v) && get_context().is_relevant(r)) { + if (is_representative(v) && ctx.is_relevant(r)) { for (enode * parent : r->get_const_parents()) { if (parent->get_cg() == parent && - get_context().is_relevant(parent) && + ctx.is_relevant(parent) && is_select(parent) && parent->get_arg(0)->get_root() == r) { select_set * s = get_select_set(r); @@ -835,11 +815,11 @@ namespace smt { void theory_array_base::propagate_select_to_store_parents(enode * r, enode * sel, enode_pair_vector & todo) { SASSERT(r->get_root() == r); SASSERT(is_select(sel)); - if (!get_context().is_relevant(r)) { + if (!ctx.is_relevant(r)) { return; } for (enode * parent : r->get_const_parents()) { - if (get_context().is_relevant(parent) && + if (ctx.is_relevant(parent) && is_store(parent) && parent->get_arg(0)->get_root() == r) { // propagate upward @@ -999,11 +979,11 @@ namespace smt { return is_decl_of(f, get_id(), OP_ARRAY_EXT); } - model_value_proc * theory_array_base::mk_value(enode * n, model_generator & m) { - SASSERT(get_context().is_relevant(n)); + model_value_proc * theory_array_base::mk_value(enode * n, model_generator & mg) { + SASSERT(ctx.is_relevant(n)); theory_var v = n->get_th_var(get_id()); SASSERT(v != null_theory_var); - sort * s = get_manager().get_sort(n->get_owner()); + sort * s = m.get_sort(n->get_owner()); enode * else_val_n = get_default(v); array_value_proc * result = nullptr; @@ -1013,7 +993,7 @@ namespace smt { } else { if (else_val_n != nullptr) { - SASSERT(get_context().is_relevant(else_val_n)); + SASSERT(ctx.is_relevant(else_val_n)); result = alloc(array_value_proc, get_id(), s, else_val_n); } else { @@ -1021,18 +1001,18 @@ namespace smt { void * else_val = m_else_values[r]; // DISABLED. It seems wrong, since different nodes can share the same // else_val according to the mg class. - // SASSERT(else_val == 0 || get_context().is_relevant(UNTAG(app*, else_val))); + // SASSERT(else_val == 0 || ctx.is_relevant(UNTAG(app*, else_val))); if (else_val == nullptr) { sort * range = to_sort(s->get_parameter(s->get_num_parameters() - 1).get_ast()); // IMPORTANT: // The implementation should not assume a fresh value is created for // the else_val if the range is finite - TRACE("array", tout << mk_pp(n->get_owner(), get_manager()) << " " << mk_pp(range, get_manager()) << " " << range->is_infinite() << "\n";); + TRACE("array", tout << mk_pp(n->get_owner(), m) << " " << mk_pp(range, m) << " " << range->is_infinite() << "\n";); if (range->is_infinite()) - else_val = TAG(void*, m.mk_extra_fresh_value(range), 1); + else_val = TAG(void*, mg.mk_extra_fresh_value(range), 1); else - else_val = TAG(void*, m.get_some_value(range), 0); + else_val = TAG(void*, mg.get_some_value(range), 0); m_else_values[r] = else_val; } if (GET_TAG(else_val) == 0) { @@ -1053,19 +1033,19 @@ namespace smt { unsigned num = select->get_num_args(); for (unsigned j = 1; j < num; ++j) args.push_back(select->get_arg(j)); - SASSERT(get_context().is_relevant(select)); + SASSERT(ctx.is_relevant(select)); result->add_entry(args.size(), args.c_ptr(), select); } } TRACE("array", - tout << mk_pp(n->get_root()->get_owner(), get_manager()) << "\n"; + tout << mk_pp(n->get_root()->get_owner(), m) << "\n"; if (sel_set) { for (enode* s : *sel_set) { - tout << "#" << s->get_root()->get_owner()->get_id() << " " << mk_pp(s->get_owner(), get_manager()) << "\n"; + tout << "#" << s->get_root()->get_owner()->get_id() << " " << mk_pp(s->get_owner(), m) << "\n"; } } if (else_val_n) { - tout << "else: " << mk_pp(else_val_n->get_owner(), get_manager()) << "\n"; + tout << "else: " << mk_pp(else_val_n->get_owner(), m) << "\n"; }); return result; } diff --git a/src/smt/theory_array_base.h b/src/smt/theory_array_base.h index 6da19b95c..b6607cb2f 100644 --- a/src/smt/theory_array_base.h +++ b/src/smt/theory_array_base.h @@ -207,7 +207,7 @@ namespace smt { model_value_proc * mk_value(enode * n, model_generator & m) override; bool include_func_interp(func_decl* f) override; public: - theory_array_base(ast_manager & m); + theory_array_base(context& ctx); ~theory_array_base() override { restore_sorts(0); } }; diff --git a/src/smt/theory_array_full.cpp b/src/smt/theory_array_full.cpp index 85dfa7a7b..c6e4c106d 100644 --- a/src/smt/theory_array_full.cpp +++ b/src/smt/theory_array_full.cpp @@ -27,9 +27,9 @@ Revision History: namespace smt { - theory_array_full::theory_array_full(ast_manager & m, theory_array_params & params) : - theory_array(m, params), - m_sort2epsilon(m) {} + theory_array_full::theory_array_full(context& ctx) : + theory_array(ctx), + m_sort2epsilon(ctx.get_manager()) {} theory_array_full::~theory_array_full() { std::for_each(m_var_data_full.begin(), m_var_data_full.end(), delete_proc()); @@ -37,7 +37,7 @@ namespace smt { } theory* theory_array_full::mk_fresh(context* new_ctx) { - return alloc(theory_array_full, new_ctx->get_manager(), new_ctx->get_fparams()); + return alloc(theory_array_full, *new_ctx); } void theory_array_full::add_map(theory_var v, enode* s) { @@ -133,7 +133,7 @@ namespace smt { // call set_prop_upward on array arguments. // void theory_array_full::set_prop_upward(enode * n) { - TRACE("array", tout << mk_pp(n->get_owner(), get_manager()) << "\n";); + TRACE("array", tout << mk_pp(n->get_owner(), m) << "\n";); if (is_store(n)) { set_prop_upward(n->get_arg(0)->get_th_var(get_id())); } @@ -246,11 +246,10 @@ namespace smt { } bool theory_array_full::internalize_term(app * n) { - context & ctx = get_context(); if (ctx.e_internalized(n)) { return true; } - TRACE("array", tout << mk_pp(n, get_manager()) << "\n";); + TRACE("array", tout << mk_pp(n, m) << "\n";); if (is_store(n) || is_select(n)) { return theory_array::internalize_term(n); @@ -345,8 +344,8 @@ namespace smt { add_as_array(v1, n); } TRACE("array", - tout << mk_pp(get_enode(v1)->get_owner(), get_manager()) << "\n"; - tout << mk_pp(get_enode(v2)->get_owner(), get_manager()) << "\n"; + tout << mk_pp(get_enode(v1)->get_owner(), m) << "\n"; + tout << mk_pp(get_enode(v2)->get_owner(), m) << "\n"; tout << "merge in\n"; display_var(tout, v2); tout << "after merge\n"; display_var(tout, v1);); } @@ -355,7 +354,7 @@ namespace smt { SASSERT(v != null_theory_var); v = find(v); var_data* d = m_var_data[v]; - TRACE("array", tout << "v" << v << " " << mk_pp(get_enode(v)->get_owner(), get_manager()) << " " + TRACE("array", tout << "v" << v << " " << mk_pp(get_enode(v)->get_owner(), m) << " " << d->m_prop_upward << " " << m_params.m_array_delay_exp_axiom << "\n";); for (enode * store : d->m_stores) { SASSERT(is_store(store)); @@ -369,7 +368,7 @@ namespace smt { void theory_array_full::add_parent_select(theory_var v, enode * s) { TRACE("array", - tout << v << " select parent: " << mk_pp(s->get_owner(), get_manager()) << "\n"; + tout << v << " select parent: " << mk_pp(s->get_owner(), m) << "\n"; display_var(tout, v); ); theory_array::add_parent_select(v,s); @@ -394,12 +393,11 @@ namespace smt { } void theory_array_full::relevant_eh(app* n) { - TRACE("array", tout << mk_pp(n, get_manager()) << "\n";); + TRACE("array", tout << mk_pp(n, m) << "\n";); theory_array::relevant_eh(n); if (!is_default(n) && !is_select(n) && !is_map(n) && !is_const(n) && !is_as_array(n)){ return; } - context & ctx = get_context(); if (!ctx.e_internalized(n)) ctx.internalize(n, false);; enode* node = ctx.get_enode(n); if (is_select(n)) { @@ -455,8 +453,6 @@ namespace smt { SASSERT(map->get_num_args() > 0); func_decl* f = to_func_decl(map->get_decl()->get_parameter(0).get_ast()); - context& ctx = get_context(); - ast_manager& m = get_manager(); TRACE("array_map_bug", tout << "invoked instantiate_select_map_axiom\n"; tout << sl->get_owner_id() << " " << mp->get_owner_id() << "\n"; @@ -470,8 +466,8 @@ namespace smt { m_stats.m_num_map_axiom++; TRACE("array", - tout << mk_bounded_pp(mp->get_owner(), get_manager()) << "\n"; - tout << mk_bounded_pp(sl->get_owner(), get_manager()) << "\n";); + tout << mk_bounded_pp(mp->get_owner(), m) << "\n"; + tout << mk_bounded_pp(sl->get_owner(), m) << "\n";); unsigned num_args = select->get_num_args(); unsigned num_arrays = map->get_num_args(); ptr_buffer args1, args2; @@ -518,12 +514,10 @@ namespace smt { SASSERT(is_map(mp)); app* map = mp->get_owner(); - ast_manager& m = get_manager(); - context& ctx = get_context(); if (!ctx.add_fingerprint(this, m_default_map_fingerprint, 1, &mp)) { return false; } - TRACE("array", tout << mk_bounded_pp(map, get_manager()) << "\n";); + TRACE("array", tout << mk_bounded_pp(map, m) << "\n";); m_stats.m_num_default_map_axiom++; @@ -544,13 +538,12 @@ namespace smt { bool theory_array_full::instantiate_default_const_axiom(enode* cnst) { - context& ctx = get_context(); if (!ctx.add_fingerprint(this, m_default_const_fingerprint, 1, &cnst)) { return false; } m_stats.m_num_default_const_axiom++; SASSERT(is_const(cnst)); - TRACE("array", tout << mk_bounded_pp(cnst->get_owner(), get_manager()) << "\n";); + TRACE("array", tout << mk_bounded_pp(cnst->get_owner(), m) << "\n";); expr* val = cnst->get_arg(0)->get_owner(); expr* def = mk_default(cnst->get_owner()); ctx.internalize(def, false); @@ -565,20 +558,19 @@ namespace smt { bool theory_array_full::instantiate_default_as_array_axiom(enode* arr) { return false; #if 0 - context& ctx = get_context(); if (!ctx.add_fingerprint(this, m_default_as_array_fingerprint, 1, &arr)) { return false; } m_stats.m_num_default_as_array_axiom++; SASSERT(is_as_array(arr)); - TRACE("array", tout << mk_bounded_pp(arr->get_owner(), get_manager()) << "\n";); + TRACE("array", tout << mk_bounded_pp(arr->get_owner(), m) << "\n";); expr* def = mk_default(arr->get_owner()); - func_decl * f = array_util(get_manager()).get_as_array_func_decl(arr->get_owner()); + func_decl * f = array_util(m).get_as_array_func_decl(arr->get_owner()); ptr_vector args; for (unsigned i = 0; i < f->get_arity(); ++i) { args.push_back(mk_epsilon(f->get_domain(i))); } - expr_ref val(get_manager().mk_app(f, args.size(), args.c_ptr()), get_manager()); + expr_ref val(m.mk_app(f, args.size(), args.c_ptr()), m); ctx.internalize(def, false); ctx.internalize(val.get(), false); return try_assign_eq(val.get(), def); @@ -587,7 +579,7 @@ namespace smt { bool theory_array_full::has_large_domain(app* array_term) { SASSERT(is_array_sort(array_term)); - sort* s = get_manager().get_sort(array_term); + sort* s = m.get_sort(array_term); unsigned dim = get_dimension(s); parameter const * params = s->get_info()->get_parameters(); rational sz(1); @@ -613,7 +605,6 @@ namespace smt { SASSERT(is_const(cnst)); SASSERT(is_select(select)); SASSERT(cnst->get_num_args() == 1); - context& ctx = get_context(); unsigned num_args = select->get_num_args(); if (!ctx.add_fingerprint(cnst, cnst->get_owner_id(), select->get_num_args() - 1, select->get_args() + 1)) { return false; @@ -628,10 +619,10 @@ namespace smt { expr * sel = mk_select(sel_args.size(), sel_args.c_ptr()); expr * val = cnst->get_owner()->get_arg(0); TRACE("array", tout << "new select-const axiom...\n"; - tout << "const: " << mk_bounded_pp(cnst->get_owner(), get_manager()) << "\n"; - tout << "select: " << mk_bounded_pp(select->get_owner(), get_manager()) << "\n"; - tout << " sel/const: " << mk_bounded_pp(sel, get_manager()) << "\n"; - tout << "value: " << mk_bounded_pp(val, get_manager()) << "\n"; + tout << "const: " << mk_bounded_pp(cnst->get_owner(), m) << "\n"; + tout << "select: " << mk_bounded_pp(select->get_owner(), m) << "\n"; + tout << " sel/const: " << mk_bounded_pp(sel, m) << "\n"; + tout << "value: " << mk_bounded_pp(val, m) << "\n"; tout << "#" << sel->get_id() << " = #" << val->get_id() << "\n"; ); @@ -648,7 +639,6 @@ namespace smt { SASSERT(is_as_array(arr->get_owner())); SASSERT(is_select(select)); SASSERT(arr->get_num_args() == 0); - context& ctx = get_context(); unsigned num_args = select->get_num_args(); if (!ctx.add_fingerprint(arr, arr->get_owner_id(), select->get_num_args() - 1, select->get_args() + 1)) { return false; @@ -661,13 +651,13 @@ namespace smt { sel_args.push_back(select->get_owner()->get_arg(i)); } expr * sel = mk_select(sel_args.size(), sel_args.c_ptr()); - func_decl * f = array_util(get_manager()).get_as_array_func_decl(arr->get_owner()); - expr_ref val(get_manager().mk_app(f, sel_args.size()-1, sel_args.c_ptr()+1), get_manager()); + func_decl * f = array_util(m).get_as_array_func_decl(arr->get_owner()); + expr_ref val(m.mk_app(f, sel_args.size()-1, sel_args.c_ptr()+1), m); TRACE("array", tout << "new select-as-array axiom...\n"; - tout << "as-array: " << mk_bounded_pp(arr->get_owner(), get_manager()) << "\n"; - tout << "select: " << mk_bounded_pp(select->get_owner(), get_manager()) << "\n"; - tout << " sel/as-array: " << mk_bounded_pp(sel, get_manager()) << "\n"; - tout << "value: " << mk_bounded_pp(val.get(), get_manager()) << "\n"; + tout << "as-array: " << mk_bounded_pp(arr->get_owner(), m) << "\n"; + tout << "select: " << mk_bounded_pp(select->get_owner(), m) << "\n"; + tout << " sel/as-array: " << mk_bounded_pp(sel, m) << "\n"; + tout << "value: " << mk_bounded_pp(val.get(), m) << "\n"; tout << "#" << sel->get_id() << " = #" << val->get_id() << "\n"; ); @@ -681,8 +671,6 @@ namespace smt { SASSERT(is_store(store)); SASSERT(store->get_num_args() >= 3); app* store_app = store->get_owner(); - context& ctx = get_context(); - ast_manager& m = get_manager(); if (!ctx.add_fingerprint(this, m_default_store_fingerprint, store->get_num_args(), store->get_args())) { return false; } @@ -729,7 +717,7 @@ namespace smt { if (m_sort2epsilon.find(s, eps)) { return eps; } - eps = get_manager().mk_fresh_const("epsilon", s); + eps = m.mk_fresh_const("epsilon", s); m_trail_stack.push( ast2ast_trail(m_sort2epsilon, s, eps)); return eps; @@ -756,7 +744,7 @@ namespace smt { while (!m_eqsv.empty()) { literal eq = m_eqsv.back(); m_eqsv.pop_back(); - get_context().mark_as_relevant(eq); + ctx.mark_as_relevant(eq); assert_axiom(eq); r = FC_CONTINUE; } @@ -788,8 +776,8 @@ namespace smt { bool theory_array_full::try_assign_eq(expr* v1, expr* v2) { TRACE("array", - tout << mk_bounded_pp(v1, get_manager()) << "\n==\n" - << mk_bounded_pp(v2, get_manager()) << "\n";); + tout << mk_bounded_pp(v1, m) << "\n==\n" + << mk_bounded_pp(v2, m) << "\n";); if (m_eqs.contains(v1, v2)) { return false; @@ -797,10 +785,10 @@ namespace smt { else { m_eqs.insert(v1, v2, true); literal eq(mk_eq(v1, v2, true)); - if (get_manager().has_trace_stream()) log_axiom_instantiation(get_context().bool_var2expr(eq.var())); - get_context().mark_as_relevant(eq); + if (m.has_trace_stream()) log_axiom_instantiation(ctx.bool_var2expr(eq.var())); + ctx.mark_as_relevant(eq); assert_axiom(eq); - if (get_manager().has_trace_stream()) get_manager().trace_stream() << "[end-of-instance]\n"; + if (m.has_trace_stream()) m.trace_stream() << "[end-of-instance]\n"; // m_eqsv.push_back(eq); return true; diff --git a/src/smt/theory_array_full.h b/src/smt/theory_array_full.h index 14c1d891e..37a967c2a 100644 --- a/src/smt/theory_array_full.h +++ b/src/smt/theory_array_full.h @@ -95,7 +95,7 @@ namespace smt { public: - theory_array_full(ast_manager & m, theory_array_params & params); + theory_array_full(context& ctx); ~theory_array_full() override; theory * mk_fresh(context * new_ctx) override; @@ -103,12 +103,6 @@ namespace smt { void merge_eh(theory_var v1, theory_var v2, theory_var, theory_var) override; void display_var(std::ostream & out, theory_var v) const override; void collect_statistics(::statistics & st) const override; - void init(context* ctx) override { - // the parent class is theory_array. - // theory::init(ctx); - theory_array::init(ctx); - } - }; }; diff --git a/src/smt/theory_bv.cpp b/src/smt/theory_bv.cpp index f517242f8..6e96b0b01 100644 --- a/src/smt/theory_bv.cpp +++ b/src/smt/theory_bv.cpp @@ -28,17 +28,13 @@ Revision History: namespace smt { - void theory_bv::init(context * ctx) { - theory::init(ctx); - } - theory_var theory_bv::mk_var(enode * n) { theory_var r = theory::mk_var(n); m_find.mk_var(); m_bits.push_back(literal_vector()); m_wpos.push_back(0); m_zero_one_bits.push_back(zero_one_bits()); - get_context().attach_th_var(n, this, r); + ctx.attach_th_var(n, this, r); return r; } @@ -52,7 +48,6 @@ namespace smt { enode * n = get_enode(v); app * owner = n->get_owner(); unsigned bv_size = get_bv_size(n); - context & ctx = get_context(); bool is_relevant = ctx.is_relevant(n); literal_vector & bits = m_bits[v]; TRACE("bv", tout << "v" << v << "\n";); @@ -80,7 +75,6 @@ namespace smt { }; void theory_bv::mk_bit2bool(app * n) { - context & ctx = get_context(); SASSERT(!ctx.b_internalized(n)); TRACE("bv", tout << "bit2bool: " << mk_pp(n, ctx.get_manager()) << "\n";); @@ -148,14 +142,12 @@ namespace smt { } void theory_bv::process_args(app * n) { - context & ctx = get_context(); for (expr* arg : *n) { ctx.internalize(arg, false); } } enode * theory_bv::mk_enode(app * n) { - context & ctx = get_context(); enode * e; if (ctx.e_internalized(n)) { e = ctx.get_enode(n); @@ -182,7 +174,6 @@ namespace smt { return n->get_arg(idx); } else { - context & ctx = get_context(); app * arg = to_app(n->get_owner()->get_arg(idx)); SASSERT(ctx.e_internalized(arg)); return ctx.get_enode(arg); @@ -194,7 +185,6 @@ namespace smt { } void theory_bv::get_bits(theory_var v, expr_ref_vector & r) { - context & ctx = get_context(); literal_vector & bits = m_bits[v]; for (literal lit : bits) { expr_ref l(get_manager()); @@ -212,7 +202,6 @@ namespace smt { } inline void theory_bv::get_arg_bits(app * n, unsigned idx, expr_ref_vector & r) { - context & ctx = get_context(); app * arg = to_app(n->get_arg(idx)); SASSERT(ctx.e_internalized(arg)); get_bits(ctx.get_enode(arg), r); @@ -239,8 +228,6 @@ namespace smt { enode * e1 = get_enode(v1); enode * e2 = get_enode(v2); literal l = ~(mk_eq(e1->get_owner(), e2->get_owner(), true)); - context & ctx = get_context(); - ast_manager & m = get_manager(); expr * eq = ctx.bool_var2expr(l.var()); if (m.has_trace_stream()) { app_ref body(m); @@ -282,7 +269,6 @@ namespace smt { \brief Add bit l to the given variable. */ void theory_bv::add_bit(theory_var v, literal l) { - context & ctx = get_context(); literal_vector & bits = m_bits[v]; unsigned idx = bits.size(); bits.push_back(l); @@ -314,15 +300,13 @@ namespace smt { void theory_bv::simplify_bit(expr * s, expr_ref & r) { // proof_ref p(get_manager()); - // if (get_context().at_base_level()) + // if (ctx.at_base_level()) // ctx.get_rewriter()(s, r, p); // else r = s; } void theory_bv::init_bits(enode * n, expr_ref_vector const & bits) { - context & ctx = get_context(); - ast_manager & m = get_manager(); theory_var v = n->get_th_var(get_id()); SASSERT(v != null_theory_var); unsigned sz = bits.size(); @@ -344,7 +328,6 @@ namespace smt { \brief Find an unassigned bit for m_wpos[v], if such bit cannot be found invoke fixed_var_eh */ void theory_bv::find_wpos(theory_var v) { - context & ctx = get_context(); literal_vector const & bits = m_bits[v]; unsigned sz = bits.size(); unsigned & wpos = m_wpos[v]; @@ -446,8 +429,6 @@ namespace smt { return; } ++m_stats.m_num_eq_dynamic; - ast_manager& m = get_manager(); - context & ctx = get_context(); app* o1 = get_enode(v1)->get_owner(); app* o2 = get_enode(v2)->get_owner(); literal oeq = mk_eq(o1, o2, true); @@ -492,7 +473,6 @@ namespace smt { get_bv_size(v2) == sz && get_fixed_value(v2, val2) && val == val2) { if (get_enode(v)->get_root() != get_enode(v2)->get_root()) { SASSERT(get_bv_size(v) == get_bv_size(v2)); - context & ctx = get_context(); TRACE("fixed_var_eh", tout << "detected equality: v" << v << " = v" << v2 << "\n"; display_var(tout, v); display_var(tout, v2);); @@ -515,7 +495,6 @@ namespace smt { } bool theory_bv::get_fixed_value(theory_var v, numeral & result) const { - context & ctx = get_context(); result.reset(); literal_vector const & bits = m_bits[v]; literal_vector::const_iterator it = bits.begin(); @@ -531,8 +510,7 @@ namespace smt { } bool theory_bv::get_fixed_value(app* x, numeral & result) const { - context& ctx = get_context(); - CTRACE("bv", !ctx.e_internalized(x), tout << "not internalized " << mk_pp(x, get_manager()) << "\n";); + CTRACE("bv", !ctx.e_internalized(x), tout << "not internalized " << mk_pp(x, m) << "\n";); if (!ctx.e_internalized(x)) return false; enode * e = ctx.get_enode(x); theory_var v = e->get_th_var(get_id()); @@ -541,8 +519,7 @@ namespace smt { void theory_bv::internalize_num(app * n) { - SASSERT(!get_context().e_internalized(n)); - ast_manager & m = get_manager(); + SASSERT(!ctx.e_internalized(n)); numeral val; unsigned sz; m_util.is_numeral(n, val, sz); @@ -569,7 +546,6 @@ namespace smt { } void theory_bv::internalize_mkbv(app* n) { - ast_manager& m = get_manager(); expr_ref_vector bits(m); process_args(n); enode * e = mk_enode(n); @@ -578,9 +554,8 @@ namespace smt { } void theory_bv::internalize_bv2int(app* n) { - SASSERT(!get_context().e_internalized(n)); - context& ctx = get_context(); - TRACE("bv", tout << mk_bounded_pp(n, get_manager()) << "\n";); + SASSERT(!ctx.e_internalized(n)); + TRACE("bv", tout << mk_bounded_pp(n, m) << "\n";); process_args(n); mk_enode(n); if (!ctx.relevancy()) { @@ -594,11 +569,9 @@ namespace smt { // create the axiom: // n = bv2int(k) = ite(bit2bool(k[sz-1],2^{sz-1},0) + ... + ite(bit2bool(k[0],1,0)) // - SASSERT(get_context().e_internalized(n)); + SASSERT(ctx.e_internalized(n)); SASSERT(m_util.is_bv2int(n)); - ast_manager & m = get_manager(); TRACE("bv2int_bug", tout << "bv2int:\n" << mk_pp(n, m) << "\n";); - context & ctx = get_context(); sort * int_sort = m.get_sort(n); app * k = to_app(n->get_arg(0)); SASSERT(m_util.is_bv_sort(m.get_sort(k))); @@ -648,9 +621,8 @@ namespace smt { } void theory_bv::internalize_int2bv(app* n) { - SASSERT(!get_context().e_internalized(n)); + SASSERT(!ctx.e_internalized(n)); SASSERT(n->get_num_args() == 1); - context& ctx = get_context(); process_args(n); mk_enode(n); theory_var v = ctx.get_enode(n)->get_th_var(get_id()); @@ -671,10 +643,8 @@ namespace smt { // bit2bool(i,n) == ((e div 2^i) mod 2 != 0) // for i = 0,.., sz-1 // - SASSERT(get_context().e_internalized(n)); + SASSERT(ctx.e_internalized(n)); SASSERT(m_util.is_int2bv(n)); - ast_manager & m = get_manager(); - context& ctx = get_context(); parameter param(m_autil.mk_int()); expr* n_expr = n; @@ -720,10 +690,9 @@ namespace smt { #define MK_UNARY(NAME, BLAST_OP) \ void theory_bv::NAME(app * n) { \ - SASSERT(!get_context().e_internalized(n)); \ + SASSERT(!ctx.e_internalized(n)); \ SASSERT(n->get_num_args() == 1); \ process_args(n); \ - ast_manager & m = get_manager(); \ enode * e = mk_enode(n); \ expr_ref_vector arg1_bits(m), bits(m); \ get_arg_bits(e, 0, arg1_bits); \ @@ -733,10 +702,9 @@ namespace smt { #define MK_BINARY(NAME, BLAST_OP) \ void theory_bv::NAME(app * n) { \ - SASSERT(!get_context().e_internalized(n)); \ + SASSERT(!ctx.e_internalized(n)); \ SASSERT(n->get_num_args() == 2); \ process_args(n); \ - ast_manager & m = get_manager(); \ enode * e = mk_enode(n); \ expr_ref_vector arg1_bits(m), arg2_bits(m), bits(m); \ get_arg_bits(e, 0, arg1_bits); \ @@ -749,10 +717,9 @@ namespace smt { #define MK_AC_BINARY(NAME, BLAST_OP) \ void theory_bv::NAME(app * n) { \ - SASSERT(!get_context().e_internalized(n)); \ + SASSERT(!ctx.e_internalized(n)); \ SASSERT(n->get_num_args() >= 2); \ process_args(n); \ - ast_manager & m = get_manager(); \ enode * e = mk_enode(n); \ expr_ref_vector arg_bits(m); \ expr_ref_vector bits(m); \ @@ -776,11 +743,9 @@ namespace smt { #define MK_BINARY_COND(NAME, BLAST_OP) \ void theory_bv::NAME(app * n) { \ - SASSERT(!get_context().e_internalized(n)); \ + SASSERT(!ctx.e_internalized(n)); \ SASSERT(n->get_num_args() == 2); \ process_args(n); \ - ast_manager & m = get_manager(); \ - context& ctx = get_context(); \ enode * e = mk_enode(n); \ expr_ref_vector arg1_bits(m), arg2_bits(m), bits(m); \ expr_ref cond(m), s_cond(m); \ @@ -794,14 +759,13 @@ namespace smt { literal l(ctx.get_literal(s_cond)); \ ctx.mark_as_relevant(l); \ ctx.mk_th_axiom(get_id(), 1, &l); \ - TRACE("bv", tout << mk_pp(cond, get_manager()) << "\n"; tout << l << "\n";); \ + TRACE("bv", tout << mk_pp(cond, m) << "\n"; tout << l << "\n";); \ } void theory_bv::internalize_sub(app *n) { - SASSERT(!get_context().e_internalized(n)); + SASSERT(!ctx.e_internalized(n)); SASSERT(n->get_num_args() == 2); - process_args(n); - ast_manager & m = get_manager(); + process_args(n); enode * e = mk_enode(n); expr_ref_vector arg1_bits(m), arg2_bits(m), bits(m); get_arg_bits(e, 0, arg1_bits); @@ -838,10 +802,9 @@ namespace smt { #define MK_PARAMETRIC_UNARY(NAME, BLAST_OP) \ void theory_bv::NAME(app * n) { \ - SASSERT(!get_context().e_internalized(n)); \ + SASSERT(!ctx.e_internalized(n)); \ SASSERT(n->get_num_args() == 1); \ process_args(n); \ - ast_manager & m = get_manager(); \ enode * e = mk_enode(n); \ expr_ref_vector arg1_bits(m), bits(m); \ get_arg_bits(e, 0, arg1_bits); \ @@ -890,7 +853,7 @@ namespace smt { bool theory_bv::internalize_term_core(app * term) { SASSERT(term->get_family_id() == get_family_id()); - TRACE("bv", tout << "internalizing term: " << mk_bounded_pp(term, get_manager()) << "\n";); + TRACE("bv", tout << "internalizing term: " << mk_bounded_pp(term, m) << "\n";); if (approximate_term(term)) { return false; } @@ -942,14 +905,14 @@ namespace smt { } return params().m_bv_enable_int2bv2int; default: - TRACE("bv_op", tout << "unsupported operator: " << mk_ll_pp(term, get_manager()) << "\n";); + TRACE("bv_op", tout << "unsupported operator: " << mk_ll_pp(term, m) << "\n";); UNREACHABLE(); return false; } } bool theory_bv::internalize_term(app * term) { - scoped_suspend_rlimit _suspend_cancel(get_manager().limit()); + scoped_suspend_rlimit _suspend_cancel(m.limit()); try { return internalize_term_core(term); } @@ -963,8 +926,6 @@ namespace smt { void theory_bv::NAME(app *n) { \ SASSERT(n->get_num_args() == 2); \ process_args(n); \ - ast_manager & m = get_manager(); \ - context & ctx = get_context(); \ expr_ref_vector arg1_bits(m), arg2_bits(m); \ get_arg_bits(n, 0, arg1_bits); \ get_arg_bits(n, 1, arg2_bits); \ @@ -998,8 +959,6 @@ namespace smt { void theory_bv::internalize_le(app * n) { SASSERT(n->get_num_args() == 2); process_args(n); - ast_manager & m = get_manager(); - context & ctx = get_context(); expr_ref_vector arg1_bits(m), arg2_bits(m); get_arg_bits(n, 0, arg1_bits); get_arg_bits(n, 1, arg2_bits); @@ -1024,7 +983,6 @@ namespace smt { } bool theory_bv::internalize_carry(app * n, bool gate_ctx) { - context & ctx = get_context(); ctx.internalize(n->get_arg(0), true); ctx.internalize(n->get_arg(1), true); ctx.internalize(n->get_arg(2), true); @@ -1058,7 +1016,6 @@ namespace smt { } bool theory_bv::internalize_xor3(app * n, bool gate_ctx) { - context & ctx = get_context(); ctx.internalize(n->get_arg(0), true); ctx.internalize(n->get_arg(1), true); ctx.internalize(n->get_arg(2), true); @@ -1094,7 +1051,7 @@ namespace smt { } bool theory_bv::internalize_atom(app * atom, bool gate_ctx) { - TRACE("bv", tout << "internalizing atom: " << mk_bounded_pp(atom, get_manager()) << "\n";); + TRACE("bv", tout << "internalizing atom: " << mk_bounded_pp(atom, m) << "\n";); SASSERT(atom->get_family_id() == get_family_id()); if (approximate_term(atom)) { return false; @@ -1125,11 +1082,11 @@ namespace smt { unsigned num_args = n->get_num_args(); for (unsigned i = 0; i <= num_args; i++) { expr* arg = (i == num_args)?n:n->get_arg(i); - sort* s = get_manager().get_sort(arg); + sort* s = m.get_sort(arg); if (m_util.is_bv_sort(s) && m_util.get_bv_size(arg) > params().m_bv_blast_max_size) { if (!m_approximates_large_bvs) { - TRACE("bv", tout << "found large size bit-vector:\n" << mk_pp(n, get_manager()) << "\n";); - get_context().push_trail(value_trail(m_approximates_large_bvs)); + TRACE("bv", tout << "found large size bit-vector:\n" << mk_pp(n, m) << "\n";); + ctx.push_trail(value_trail(m_approximates_large_bvs)); m_approximates_large_bvs = true; } return true; @@ -1141,17 +1098,17 @@ namespace smt { void theory_bv::apply_sort_cnstr(enode * n, sort * s) { if (!is_attached_to_var(n) && !approximate_term(n->get_owner())) { mk_bits(mk_var(n)); - if (get_context().is_relevant(n)) { + if (ctx.is_relevant(n)) { relevant_eh(n->get_owner()); } } } void theory_bv::new_eq_eh(theory_var v1, theory_var v2) { - TRACE("bv_eq", tout << "new_eq: " << mk_pp(get_enode(v1)->get_owner(), get_manager()) << " = " << mk_pp(get_enode(v2)->get_owner(), get_manager()) << "\n";); - TRACE("bv", tout << "new_eq_eh v" << v1 << " = v" << v2 << " @ " << get_context().get_scope_level() << - " relevant1: " << get_context().is_relevant(get_enode(v1)) << - " relevant2: " << get_context().is_relevant(get_enode(v2)) << "\n";); + TRACE("bv_eq", tout << "new_eq: " << mk_pp(get_enode(v1)->get_owner(), m) << " = " << mk_pp(get_enode(v2)->get_owner(), m) << "\n";); + TRACE("bv", tout << "new_eq_eh v" << v1 << " = v" << v2 << " @ " << ctx.get_scope_level() << + " relevant1: " << ctx.is_relevant(get_enode(v1)) << + " relevant2: " << ctx.is_relevant(get_enode(v2)) << "\n";); m_find.merge(v1, v2); } @@ -1164,8 +1121,6 @@ namespace smt { void theory_bv::expand_diseq(theory_var v1, theory_var v2) { SASSERT(get_bv_size(v1) == get_bv_size(v2)); - context & ctx = get_context(); - ast_manager & m = get_manager(); if (v1 > v2) { std::swap(v1, v2); } @@ -1242,7 +1197,7 @@ namespace smt { void theory_bv::assign_eh(bool_var v, bool is_true) { atom * a = get_bv2a(v); - TRACE("bv", tout << "assert: p" << v << " #" << get_context().bool_var2expr(v)->get_id() << " is_true: " << is_true << "\n";); + TRACE("bv", tout << "assert: p" << v << " #" << ctx.bool_var2expr(v)->get_id() << " is_true: " << is_true << "\n";); if (a->is_bit()) { // The following optimization is not correct. // Boolean variables created for performing bit-blasting are reused. @@ -1262,7 +1217,7 @@ namespace smt { propagate_bits(); #if WATCH_DISEQ - if (!get_context().inconsistent() && m_diseq_watch.size() > static_cast(v)) { + if (!ctx.inconsistent() && m_diseq_watch.size() > static_cast(v)) { unsigned sz = m_diseq_watch[v].size(); for (unsigned i = 0; i < sz; ++i) { auto const & p = m_diseq_watch[v][i]; @@ -1275,7 +1230,6 @@ namespace smt { } void theory_bv::propagate_bits() { - context & ctx = get_context(); for (unsigned i = 0; i < m_prop_queue.size(); i++) { var_pos const & entry = m_prop_queue[i]; theory_var v = entry.first; @@ -1327,8 +1281,6 @@ namespace smt { void theory_bv::assign_bit(literal consequent, theory_var v1, theory_var v2, unsigned idx, literal antecedent, bool propagate_eqc) { m_stats.m_num_bit2core++; - context & ctx = get_context(); - ast_manager & m = get_manager(); SASSERT(ctx.get_assignment(antecedent) == l_true); SASSERT(m_bits[v2][idx].var() == consequent.var()); SASSERT(consequent.var() != antecedent.var()); @@ -1389,8 +1341,6 @@ namespace smt { } void theory_bv::relevant_eh(app * n) { - ast_manager & m = get_manager(); - context & ctx = get_context(); TRACE("bv", tout << "relevant: " << ctx.e_internalized(n) << ": " << mk_pp(n, m) << "\n";); if (m.is_bool(n)) { bool_var v = ctx.get_bool_var(n); @@ -1450,8 +1400,8 @@ namespace smt { m_diseq_watch_lim.shrink(m_diseq_watch_lim.size()-num_scopes); #endif theory::pop_scope_eh(num_scopes); - TRACE("bv_verbose", m_find.display(tout << get_context().get_scope_level() << " - " - << num_scopes << " = " << (get_context().get_scope_level() - num_scopes) << "\n");); + TRACE("bv_verbose", m_find.display(tout << ctx.get_scope_level() << " - " + << num_scopes << " = " << (ctx.get_scope_level() - num_scopes) << "\n");); } final_check_status theory_bv::final_check_eh() { @@ -1485,14 +1435,14 @@ namespace smt { } smt_params const& theory_bv::params() const { - return get_context().get_fparams(); + return ctx.get_fparams(); } - theory_bv::theory_bv(ast_manager & m, bit_blaster_params const & bb_params): - theory(m.mk_family_id("bv")), - m_util(m), - m_autil(m), - m_bb(m, bb_params), + theory_bv::theory_bv(context& ctx): + theory(ctx, ctx.get_manager().mk_family_id("bv")), + m_util(ctx.get_manager()), + m_autil(ctx.get_manager()), + m_bb(ctx.get_manager(), ctx.get_fparams()), m_trail_stack(*this), m_find(*this), m_approximates_large_bvs(false) { @@ -1504,7 +1454,7 @@ namespace smt { } theory* theory_bv::mk_fresh(context* new_ctx) { - return alloc(theory_bv, new_ctx->get_manager(), new_ctx->get_fparams()); + return alloc(theory_bv, *new_ctx); } @@ -1516,7 +1466,6 @@ namespace smt { return; // conflict was detected } m_prop_queue.reset(); - context & ctx = get_context(); literal_vector & bits1 = m_bits[v1]; literal_vector & bits2 = m_bits[v2]; SASSERT(bits1.size() == bits2.size()); @@ -1680,7 +1629,7 @@ namespace smt { }; inline justification * theory_bv::mk_bit_eq_justification(theory_var v1, theory_var v2, literal consequent, literal antecedent) { - return get_context().mk_justification(bit_eq_justification(get_id(), get_enode(v1), get_enode(v2), consequent, antecedent)); + return ctx.mk_justification(bit_eq_justification(get_id(), get_enode(v1), get_enode(v2), consequent, antecedent)); } void theory_bv::unmerge_eh(theory_var v1, theory_var v2) { @@ -1717,9 +1666,9 @@ namespace smt { // SASSERT(check_zero_one_bits(v2)); } - void theory_bv::init_model(model_generator & m) { - m_factory = alloc(bv_factory, get_manager()); - m.register_factory(m_factory); + void theory_bv::init_model(model_generator & mg) { + m_factory = alloc(bv_factory, m); + mg.register_factory(m_factory); } model_value_proc * theory_bv::mk_value(enode * n, model_generator & mg) { @@ -1744,7 +1693,6 @@ namespace smt { out.width(4); out << get_enode(find(v))->get_owner_id(); out << std::right << ", bits:"; - context & ctx = get_context(); literal_vector const & bits = m_bits[v]; for (literal lit : bits) { out << " " << lit << ":"; @@ -1757,7 +1705,6 @@ namespace smt { } void theory_bv::display_bit_atom(std::ostream & out, bool_var v, bit_atom const * a) const { - context & ctx = get_context(); out << "#" << ctx.bool_var2expr(v)->get_id() << " ->"; var_pos_occ * curr = a->m_occs; while (curr) { @@ -1769,7 +1716,6 @@ namespace smt { void theory_bv::display_atoms(std::ostream & out) const { out << "atoms:\n"; - context & ctx = get_context(); unsigned num = ctx.get_num_bool_vars(); for (unsigned v = 0; v < num; v++) { atom * a = get_bv2a(v); @@ -1798,7 +1744,6 @@ namespace smt { } bool theory_bv::check_assignment(theory_var v) { - context & ctx = get_context(); if (!is_root(v)) return true; if (!ctx.is_relevant(get_enode(v))) { @@ -1843,7 +1788,7 @@ namespace smt { \remark The method does nothing if v is not the root of the equivalence class. */ bool theory_bv::check_zero_one_bits(theory_var v) { - if (get_context().inconsistent()) + if (ctx.inconsistent()) return true; // property is only valid if the context is not in a conflict. if (is_root(v) && is_bv(v)) { bool_vector bits[2]; @@ -1887,9 +1832,9 @@ namespace smt { } bool theory_bv::check_invariant() { - if (get_manager().limit().get_cancel_flag()) + if (m.limit().get_cancel_flag()) return true; - if (get_context().inconsistent()) + if (ctx.inconsistent()) return true; unsigned num = get_num_vars(); for (unsigned v = 0; v < num; v++) { diff --git a/src/smt/theory_bv.h b/src/smt/theory_bv.h index 70584265b..95fcd39fd 100644 --- a/src/smt/theory_bv.h +++ b/src/smt/theory_bv.h @@ -223,7 +223,6 @@ namespace smt { void assert_bv2int_axiom(app* n); protected: - void init(context * ctx) override; theory_var mk_var(enode * n) override; bool internalize_atom(app * atom, bool gate_ctx) override; bool internalize_term(app * term) override; @@ -254,7 +253,7 @@ namespace smt { smt_params const& params() const; public: - theory_bv(ast_manager & m, bit_blaster_params const & bb_params); + theory_bv(context& ctx); ~theory_bv() override; theory * mk_fresh(context * new_ctx) override; diff --git a/src/smt/theory_datatype.cpp b/src/smt/theory_datatype.cpp index 0d852a9a5..004f69bd1 100644 --- a/src/smt/theory_datatype.cpp +++ b/src/smt/theory_datatype.cpp @@ -75,7 +75,7 @@ namespace smt { theory* theory_datatype::mk_fresh(context* new_ctx) { - return alloc(theory_datatype, new_ctx->get_manager()); + return alloc(theory_datatype, *new_ctx); } /** @@ -83,19 +83,17 @@ namespace smt { antecedent may be null_literal */ void theory_datatype::assert_eq_axiom(enode * lhs, expr * rhs, literal antecedent) { - ast_manager & m = get_manager(); if (antecedent != null_literal) { std::function fn = [&]() { app_ref body(m); body = m.mk_eq(lhs->get_owner(), rhs); - body = m.mk_implies(get_context().bool_var2expr(antecedent.var()), body); + body = m.mk_implies(ctx.bool_var2expr(antecedent.var()), body); log_axiom_instantiation(body, 1, &lhs); }; scoped_trace_stream _st(m, fn); } - context & ctx = get_context(); if (m.proofs_enabled()) { literal l(mk_eq(lhs->get_owner(), rhs, true)); ctx.mark_as_relevant(l); @@ -139,13 +137,12 @@ namespace smt { where acc_i are the accessors of constructor c. */ void theory_datatype::assert_is_constructor_axiom(enode * n, func_decl * c, literal antecedent) { - ast_manager& m = get_manager(); app* e = n->get_owner(); TRACE("datatype_bug", tout << "creating axiom (= n (c (acc_1 n) ... (acc_m n))) for\n" << mk_pp(c, m) << " " << mk_pp(e, m) << "\n";); m_stats.m_assert_cnstr++; SASSERT(m_util.is_constructor(c)); - SASSERT(m_util.is_datatype(get_manager().get_sort(e))); + SASSERT(m_util.is_datatype(m.get_sort(e))); SASSERT(c->get_range() == m.get_sort(e)); ptr_vector args; @@ -170,7 +167,6 @@ namespace smt { m_stats.m_assert_accessor++; SASSERT(is_constructor(n)); - ast_manager & m = get_manager(); func_decl * d = n->get_decl(); ptr_vector const & accessors = *m_util.get_constructor_accessors(d); SASSERT(n->get_num_args() == accessors.size()); @@ -180,7 +176,7 @@ namespace smt { for (unsigned i = 0; i < n->get_num_args(); ++i) { bindings.push_back(n->get_arg(i)->get_owner()); } - unsigned base_id = get_manager().has_trace_stream() && accessors.size() > 0 ? m_util.plugin().get_axiom_base_id(d->get_name()) : 0; + unsigned base_id = m.has_trace_stream() && accessors.size() > 0 ? m_util.plugin().get_axiom_base_id(d->get_name()) : 0; unsigned i = 0; for (func_decl * acc : accessors) { app_ref acc_app(m.mk_app(acc, n->get_owner()), m); @@ -206,8 +202,7 @@ namespace smt { SASSERT(m_util.get_recognizer_constructor(r->get_decl()) == c->get_decl()); SASSERT(c->get_root() == r->get_arg(0)->get_root()); TRACE("recognizer_conflict", - tout << mk_ismt2_pp(c->get_owner(), get_manager()) << "\n" << mk_ismt2_pp(r->get_owner(), get_manager()) << "\n";); - context & ctx = get_context(); + tout << mk_ismt2_pp(c->get_owner(), m) << "\n" << mk_ismt2_pp(r->get_owner(), m) << "\n";); literal l(ctx.enode2bool_var(r)); SASSERT(ctx.get_assignment(l) == l_false); l.neg(); @@ -228,8 +223,6 @@ namespace smt { void theory_datatype::assert_update_field_axioms(enode * n) { m_stats.m_assert_update_field++; SASSERT(is_update_field(n)); - context & ctx = get_context(); - ast_manager & m = get_manager(); app* own = n->get_owner(); expr* arg1 = own->get_arg(0); func_decl * upd = n->get_decl(); @@ -272,7 +265,6 @@ namespace smt { SASSERT(r == static_cast(m_var_data.size())); m_var_data.push_back(alloc(var_data)); var_data * d = m_var_data[r]; - context & ctx = get_context(); ctx.attach_th_var(n, this, r); if (is_constructor(n)) { d->m_constructor = n; @@ -282,7 +274,6 @@ namespace smt { assert_update_field_axioms(n); } else { - ast_manager & m = get_manager(); sort * s = m.get_sort(n->get_owner()); if (m_util.get_datatype_num_constructors(s) == 1) { func_decl * c = m_util.get_datatype_constructors(s)->get(0); @@ -297,21 +288,20 @@ namespace smt { } bool theory_datatype::internalize_atom(app * atom, bool gate_ctx) { - TRACE("datatype", tout << "internalizing atom:\n" << mk_pp(atom, get_manager()) << "\n";); + TRACE("datatype", tout << "internalizing atom:\n" << mk_pp(atom, m) << "\n";); return internalize_term(atom); } bool theory_datatype::internalize_term(app * term) { - TRACE("datatype", tout << "internalizing term:\n" << mk_pp(term, get_manager()) << "\n";); - context & ctx = get_context(); + TRACE("datatype", tout << "internalizing term:\n" << mk_pp(term, m) << "\n";); unsigned num_args = term->get_num_args(); for (unsigned i = 0; i < num_args; i++) ctx.internalize(term->get_arg(i), false); // the internalization of the arguments may trigger the internalization of term. if (ctx.e_internalized(term)) return true; - enode * e = ctx.mk_enode(term, false, get_manager().is_bool(term), true); // possible optimization, the third argument may be set to false, if the term (actually, atom) is not in the context of a gate. - if (get_manager().is_bool(term)) { + enode * e = ctx.mk_enode(term, false, m.is_bool(term), true); // possible optimization, the third argument may be set to false, if the term (actually, atom) is not in the context of a gate. + if (m.is_bool(term)) { bool_var bv = ctx.mk_bool_var(term); ctx.set_var_theory(bv, get_id()); ctx.set_enode_flag(bv, true); @@ -342,9 +332,9 @@ namespace smt { // for (unsigned i = 0; i < num_args; i++) { enode * arg = e->get_arg(i); - sort * s = get_manager().get_sort(arg->get_owner()); + sort * s = m.get_sort(arg->get_owner()); if (m_autil.is_array(s) && m_util.is_datatype(get_array_range(s))) { - app_ref def(m_autil.mk_default(arg->get_owner()), get_manager()); + app_ref def(m_autil.mk_default(arg->get_owner()), m); if (!ctx.e_internalized(def)) { ctx.internalize(def, false); } @@ -389,16 +379,16 @@ namespace smt { // (assert (> (len a) 1) // // If the theory variable is not created for 'a', then a wrong model will be generated. - TRACE("datatype", tout << "apply_sort_cnstr: #" << n->get_owner_id() << " " << mk_pp(n->get_owner(), get_manager()) << "\n";); + TRACE("datatype", tout << "apply_sort_cnstr: #" << n->get_owner_id() << " " << mk_pp(n->get_owner(), m) << "\n";); TRACE("datatype_bug", - tout << "apply_sort_cnstr:\n" << mk_pp(n->get_owner(), get_manager()) << " "; + tout << "apply_sort_cnstr:\n" << mk_pp(n->get_owner(), m) << " "; tout << m_util.is_datatype(s) << " "; if (m_util.is_datatype(s)) tout << "is-infinite: " << s->is_infinite() << " "; if (m_util.is_datatype(s)) tout << "attached: " << is_attached_to_var(n) << " "; tout << "\n";); if (!is_attached_to_var(n) && - (get_context().has_quantifiers() || + (ctx.has_quantifiers() || (m_util.is_datatype(s) && m_util.has_nested_arrays()) || (m_util.is_datatype(s) && !s->is_infinite()))) { mk_var(n); @@ -418,7 +408,6 @@ namespace smt { } void theory_datatype::assign_eh(bool_var v, bool is_true) { - context & ctx = get_context(); enode * n = ctx.bool_var2enode(v); if (!is_recognizer(n)) return; @@ -451,8 +440,7 @@ namespace smt { } void theory_datatype::relevant_eh(app * n) { - context & ctx = get_context(); - TRACE("datatype", tout << "relevant_eh: " << mk_pp(n, get_manager()) << "\n";); + TRACE("datatype", tout << "relevant_eh: " << mk_pp(n, m) << "\n";); SASSERT(ctx.relevancy()); if (is_recognizer(n)) { SASSERT(ctx.e_internalized(n)); @@ -522,7 +510,6 @@ namespace smt { // collect equalities on all children that may have been used. bool found = false; - ast_manager& m = get_manager(); for (enode * arg : enode::args(parentc)) { // found an argument which is equal to root if (arg->get_root() == child->get_root()) { @@ -548,7 +535,7 @@ namespace smt { // explain the cycle root -> ... -> app -> root void theory_datatype::occurs_check_explain(enode * app, enode * root) { - TRACE("datatype", tout << "occurs_check_explain " << mk_bounded_pp(app->get_owner(), get_manager()) << " <-> " << mk_bounded_pp(root->get_owner(), get_manager()) << "\n";); + TRACE("datatype", tout << "occurs_check_explain " << mk_bounded_pp(app->get_owner(), m) << " <-> " << mk_bounded_pp(root->get_owner(), m) << "\n";); // first: explain that root=v, given that app=cstor(...,v,...) @@ -570,7 +557,7 @@ namespace smt { TRACE("datatype", tout << "occurs_check\n"; for (enode_pair const& p : m_used_eqs) { - tout << enode_eq_pp(p, get_context()); + tout << enode_eq_pp(p, ctx); }); } @@ -599,7 +586,7 @@ namespace smt { } // explore `arg` (with parent) expr* earg = arg->get_owner(); - sort* s = get_manager().get_sort(earg); + sort* s = m.get_sort(earg); if (m_util.is_datatype(s)) { m_parent.insert(arg->get_root(), parent); oc_push_stack(arg); @@ -613,7 +600,7 @@ namespace smt { occurs_check_explain(parent, aarg); return true; } - if (m_util.is_datatype(get_manager().get_sort(aarg->get_owner()))) { + if (m_util.is_datatype(m.get_sort(aarg->get_owner()))) { m_parent.insert(aarg->get_root(), parent); oc_push_stack(aarg); } @@ -625,12 +612,11 @@ namespace smt { ptr_vector const& theory_datatype::get_array_args(enode* n) { m_array_args.reset(); - context& ctx = get_context(); theory_array* th = dynamic_cast(ctx.get_theory(m_autil.get_family_id())); for (enode* p : th->parent_selects(n)) { m_array_args.push_back(p); } - app_ref def(m_autil.mk_default(n->get_owner()), get_manager()); + app_ref def(m_autil.mk_default(n->get_owner()), m); m_array_args.push_back(ctx.get_enode(def)); return m_array_args; } @@ -643,7 +629,7 @@ namespace smt { a3 = cons(v3, a1) */ bool theory_datatype::occurs_check(enode * n) { - TRACE("datatype", tout << "occurs check: " << enode_pp(n, get_context()) << "\n";); + TRACE("datatype", tout << "occurs check: " << enode_pp(n, ctx) << "\n";); m_stats.m_occurs_check++; bool res = false; @@ -657,7 +643,7 @@ namespace smt { if (oc_cycle_free(app)) continue; - TRACE("datatype", tout << "occurs check loop: " << enode_pp(app, get_context()) << (op==ENTER?" enter":" exit")<< "\n";); + TRACE("datatype", tout << "occurs check loop: " << enode_pp(app, ctx) << (op==ENTER?" enter":" exit")<< "\n";); switch (op) { case ENTER: @@ -672,7 +658,6 @@ namespace smt { if (res) { // m_used_eqs should contain conflict - context & ctx = get_context(); region & r = ctx.get_region(); clear_mark(); ctx.set_conflict(ctx.mk_justification(ext_theory_conflict_justification(get_id(), r, 0, nullptr, m_used_eqs.size(), m_used_eqs.c_ptr()))); @@ -698,11 +683,11 @@ namespace smt { } theory_datatype_params const& theory_datatype::params() const { - return get_context().get_fparams(); + return ctx.get_fparams(); } - theory_datatype::theory_datatype(ast_manager & m): - theory(m.mk_family_id("datatype")), + theory_datatype::theory_datatype(context& ctx): + theory(ctx, ctx.get_manager().mk_family_id("datatype")), m_util(m), m_autil(m), m_find(*this), @@ -734,7 +719,7 @@ namespace smt { var_data * d = m_var_data[v]; out << "v" << v << " #" << get_enode(v)->get_owner_id() << " -> v" << m_find.find(v) << " "; if (d->m_constructor) - out << enode_pp(d->m_constructor, get_context()); + out << enode_pp(d->m_constructor, ctx); else out << "(null)"; out << "\n"; @@ -744,9 +729,9 @@ namespace smt { return false; } - void theory_datatype::init_model(model_generator & m) { - m_factory = alloc(datatype_factory, get_manager(), m.get_model()); - m.register_factory(m_factory); + void theory_datatype::init_model(model_generator & mg) { + m_factory = alloc(datatype_factory, m, mg.get_model()); + mg.register_factory(m_factory); } class datatype_value_proc : public model_value_proc { @@ -777,10 +762,10 @@ namespace smt { result->add_dependency(arg); } TRACE("datatype", - tout << mk_pp(n->get_owner(), get_manager()) << "\n"; + tout << mk_pp(n->get_owner(), m) << "\n"; tout << "depends on\n"; for (enode* arg : enode::args(d->m_constructor)) { - tout << " " << mk_pp(arg->get_owner(), get_manager()) << "\n"; + tout << " " << mk_pp(arg->get_owner(), m) << "\n"; }); return result; } @@ -792,7 +777,6 @@ namespace smt { var_data * d1 = m_var_data[v1]; var_data * d2 = m_var_data[v2]; if (d2->m_constructor != nullptr) { - context & ctx = get_context(); if (d1->m_constructor != nullptr && d1->m_constructor->get_decl() != d2->m_constructor->get_decl()) { region & r = ctx.get_region(); enode_pair p(d1->m_constructor, d2->m_constructor); @@ -824,7 +808,6 @@ namespace smt { void theory_datatype::add_recognizer(theory_var v, enode * recognizer) { SASSERT(is_recognizer(recognizer)); - context & ctx = get_context(); v = m_find.find(v); var_data * d = m_var_data[v]; sort * s = recognizer->get_decl()->get_domain(0); @@ -867,12 +850,11 @@ namespace smt { void theory_datatype::propagate_recognizer(theory_var v, enode * recognizer) { SASSERT(is_recognizer(recognizer)); SASSERT(static_cast(m_find.find(v)) == v); - context & ctx = get_context(); SASSERT(ctx.get_assignment(recognizer) == l_false); unsigned num_unassigned = 0; unsigned unassigned_idx = UINT_MAX; enode * n = get_enode(v); - sort * dt = get_manager().get_sort(n->get_owner()); + sort * dt = m.get_sort(n->get_owner()); var_data * d = m_var_data[v]; CTRACE("datatype", d->m_recognizers.empty(), ctx.display(tout);); SASSERT(!d->m_recognizers.empty()); @@ -905,7 +887,7 @@ namespace smt { // conflict SASSERT(!lits.empty()); region & reg = ctx.get_region(); - TRACE("datatype_conflict", tout << mk_ismt2_pp(recognizer->get_owner(), get_manager()) << "\n"; + TRACE("datatype_conflict", tout << mk_ismt2_pp(recognizer->get_owner(), m) << "\n"; for (literal l : lits) { ctx.display_detailed_literal(tout, l) << "\n"; } @@ -922,7 +904,7 @@ namespace smt { if (!r) { ptr_vector const & constructors = *m_util.get_datatype_constructors(dt); func_decl * rec = m_util.get_constructor_is(constructors[unassigned_idx]); - app_ref rec_app(get_manager().mk_app(rec, n->get_owner()), get_manager()); + app_ref rec_app(m.mk_app(rec, n->get_owner()), m); ctx.internalize(rec_app, false); consequent = literal(ctx.get_bool_var(rec_app)); } @@ -948,8 +930,6 @@ namespace smt { If first is true, it means that v does not have recognizer yet. */ void theory_datatype::mk_split(theory_var v) { - context & ctx = get_context(); - ast_manager & m = get_manager(); v = m_find.find(v); enode * n = get_enode(v); sort * s = m.get_sort(n->get_owner()); diff --git a/src/smt/theory_datatype.h b/src/smt/theory_datatype.h index 4052bf867..c5a2f29be 100644 --- a/src/smt/theory_datatype.h +++ b/src/smt/theory_datatype.h @@ -130,7 +130,7 @@ namespace smt { bool is_shared(theory_var v) const override; theory_datatype_params const& params() const; public: - theory_datatype(ast_manager & m); + theory_datatype(context& ctx); ~theory_datatype() override; theory * mk_fresh(context * new_ctx) override; void display(std::ostream & out) const override; diff --git a/src/smt/theory_dense_diff_logic.h b/src/smt/theory_dense_diff_logic.h index e552ab4fc..a06502e6d 100644 --- a/src/smt/theory_dense_diff_logic.h +++ b/src/smt/theory_dense_diff_logic.h @@ -277,7 +277,7 @@ namespace smt { // // ----------------------------------- public: - theory_dense_diff_logic(ast_manager & m, theory_arith_params & p); + theory_dense_diff_logic(context& ctx); ~theory_dense_diff_logic() override { reset_eh(); } theory * mk_fresh(context * new_ctx) override; diff --git a/src/smt/theory_dense_diff_logic_def.h b/src/smt/theory_dense_diff_logic_def.h index 351900d2e..f0fa3d010 100644 --- a/src/smt/theory_dense_diff_logic_def.h +++ b/src/smt/theory_dense_diff_logic_def.h @@ -29,11 +29,11 @@ Revision History: namespace smt { template - theory_dense_diff_logic::theory_dense_diff_logic(ast_manager & m, theory_arith_params & p): - theory(m.mk_family_id("arith")), - m_params(p), - m_autil(m), - m_arith_eq_adapter(*this, p, m_autil), + theory_dense_diff_logic::theory_dense_diff_logic(context& ctx): + theory(ctx, ctx.get_manager().mk_family_id("arith")), + m_params(ctx.get_fparams()), + m_autil(ctx.get_manager()), + m_arith_eq_adapter(*this, m_autil), m_non_diff_logic_exprs(false), m_var_value_table(DEFAULT_HASHTABLE_INITIAL_CAPACITY, var_value_hash(*this), var_value_eq(*this)) { m_edges.push_back(edge()); @@ -41,12 +41,12 @@ namespace smt { template theory* theory_dense_diff_logic::mk_fresh(context * new_ctx) { - return alloc(theory_dense_diff_logic, new_ctx->get_manager(), new_ctx->get_fparams()); + return alloc(theory_dense_diff_logic, *new_ctx); } template inline app * theory_dense_diff_logic::mk_zero_for(expr * n) { - return m_autil.mk_numeral(rational(0), get_manager().get_sort(n)); + return m_autil.mk_numeral(rational(0), m.get_sort(n)); } template @@ -66,13 +66,12 @@ namespace smt { c.m_edge_id = self_edge_id; c.m_distance.reset(); SASSERT(check_vector_sizes()); - get_context().attach_th_var(n, this, v); + ctx.attach_th_var(n, this, v); return v; } template theory_var theory_dense_diff_logic::internalize_term_core(app * n) { - context & ctx = get_context(); if (ctx.e_internalized(n)) { enode * e = ctx.get_enode(n); if (is_attached_to_var(e)) @@ -125,9 +124,9 @@ namespace smt { template void theory_dense_diff_logic::found_non_diff_logic_expr(expr * n) { if (!m_non_diff_logic_exprs) { - TRACE("non_diff_logic", tout << "found non diff logic expression:\n" << mk_pp(n, get_manager()) << "\n";); - get_context().push_trail(value_trail(m_non_diff_logic_exprs)); - IF_VERBOSE(0, verbose_stream() << "(smt.diff_logic: non-diff logic expression " << mk_pp(n, get_manager()) << ")\n";); + TRACE("non_diff_logic", tout << "found non diff logic expression:\n" << mk_pp(n, m) << "\n";); + ctx.push_trail(value_trail(m_non_diff_logic_exprs)); + IF_VERBOSE(0, verbose_stream() << "(smt.diff_logic: non-diff logic expression " << mk_pp(n, m) << ")\n";); m_non_diff_logic_exprs = true; } } @@ -138,8 +137,7 @@ namespace smt { found_non_diff_logic_expr(n); // little hack... TODO: change to no_memory and return l_undef if SAT return false; } - TRACE("ddl", tout << "internalizing atom:\n" << mk_pp(n, get_manager()) << "\n";); - context & ctx = get_context(); + TRACE("ddl", tout << "internalizing atom:\n" << mk_pp(n, m) << "\n";); SASSERT(!ctx.b_internalized(n)); SASSERT(m_autil.is_le(n) || m_autil.is_ge(n)); theory_var source, target; @@ -170,15 +168,15 @@ namespace smt { s = mk_zero_for(t); } else { - TRACE("ddl", tout << "failed to internalize:\n" << mk_pp(n, get_manager()) << "\n";); + TRACE("ddl", tout << "failed to internalize:\n" << mk_pp(n, m) << "\n";); found_non_diff_logic_expr(n); return false; } - TRACE("arith", tout << expr_ref(lhs, get_manager()) << " " << expr_ref(s, get_manager()) << " " << expr_ref(t, get_manager()) << "\n";); + TRACE("arith", tout << expr_ref(lhs, m) << " " << expr_ref(s, m) << " " << expr_ref(t, m) << "\n";); source = internalize_term_core(s); target = internalize_term_core(t); if (source == null_theory_var || target == null_theory_var) { - TRACE("ddl", tout << "failed to internalize:\n" << mk_pp(n, get_manager()) << "\n";); + TRACE("ddl", tout << "failed to internalize:\n" << mk_pp(n, m) << "\n";); found_non_diff_logic_expr(n); return false; } @@ -195,18 +193,18 @@ namespace smt { m_bv2atoms.setx(bv, a, 0); m_matrix[source][target].m_occs.push_back(a); m_matrix[target][source].m_occs.push_back(a); - TRACE("ddl", tout << "succeeded internalizing:\n" << mk_pp(n, get_manager()) << "\n";); + TRACE("ddl", tout << "succeeded internalizing:\n" << mk_pp(n, m) << "\n";); return true; } template void theory_dense_diff_logic::mk_clause(literal l1, literal l2) { - get_context().mk_th_axiom(get_id(), l1, l2); + ctx.mk_th_axiom(get_id(), l1, l2); } template void theory_dense_diff_logic::mk_clause(literal l1, literal l2, literal l3) { - get_context().mk_th_axiom(get_id(), l1, l2, l3); + ctx.mk_th_axiom(get_id(), l1, l2, l3); } template @@ -215,9 +213,9 @@ namespace smt { found_non_diff_logic_expr(term); // little hack... TODO: change to no_memory and return l_undef if SAT return false; } - TRACE("ddl", tout << "internalizing term: " << mk_pp(term, get_manager()) << "\n";); + TRACE("ddl", tout << "internalizing term: " << mk_pp(term, m) << "\n";); theory_var v = internalize_term_core(term); - TRACE("ddl", tout << mk_pp(term, get_manager()) << "\ninternalization result: " << (v != null_theory_var) << "\n";); + TRACE("ddl", tout << mk_pp(term, m) << "\ninternalization result: " << (v != null_theory_var) << "\n";); if (v == null_theory_var) found_non_diff_logic_expr(term); return v != null_theory_var; @@ -225,10 +223,9 @@ namespace smt { template void theory_dense_diff_logic::internalize_eq_eh(app * atom, bool_var v) { - TRACE("ddl", tout << "eq-eh: " << mk_pp(atom, get_manager()) << "\n";); + TRACE("ddl", tout << "eq-eh: " << mk_pp(atom, m) << "\n";); if (memory::above_high_watermark()) return; - context & ctx = get_context(); app * lhs = to_app(atom->get_arg(0)); app * rhs = to_app(atom->get_arg(1)); app * s; @@ -258,13 +255,13 @@ namespace smt { template void theory_dense_diff_logic::assign_eh(bool_var v, bool is_true) { - if (get_context().has_th_justification(v, get_id())) { + if (ctx.has_th_justification(v, get_id())) { TRACE("ddl", tout << "ignoring atom propagated by the theory.\n";); return; } atom * a = m_bv2atoms.get(v, 0); if (!a) { - SASSERT(get_manager().is_eq(get_context().bool_var2expr(v))); + SASSERT(m.is_eq(ctx.bool_var2expr(v))); return; } m_stats.m_num_assertions++; @@ -540,7 +537,6 @@ namespace smt { template void theory_dense_diff_logic::assign_literal(literal l, theory_var source, theory_var target) { - context & ctx = get_context(); literal_vector & antecedents = m_tmp_literals; antecedents.reset(); get_antecedents(source, target, antecedents); @@ -553,7 +549,6 @@ namespace smt { SASSERT(c.m_edge_id != null_edge_id); numeral neg_dist = c.m_distance; neg_dist.neg(); - context & ctx = get_context(); typename atoms::const_iterator it = c.m_occs.begin(); typename atoms::const_iterator end = c.m_occs.end(); for (; it != end; ++it) { @@ -597,7 +592,6 @@ namespace smt { get_antecedents(target, source, antecedents); if (l != null_literal) antecedents.push_back(l); - context & ctx = get_context(); region & r = ctx.get_region(); ctx.set_conflict(ctx.mk_justification(theory_conflict_justification(get_id(), r, antecedents.size(), antecedents.c_ptr()))); @@ -698,7 +692,7 @@ namespace smt { out.width(5); out << std::left << get_enode(a->get_source())->get_owner_id() << " <= "; out.width(10); - out << std::left << a->get_offset() << " assignment: " << get_context().get_assignment(a->get_bool_var()) << "\n"; + out << std::left << a->get_offset() << " assignment: " << ctx.get_assignment(a->get_bool_var()) << "\n"; } template @@ -733,7 +727,7 @@ namespace smt { TRACE("ddl_model", tout << "ddl model\n"; for (theory_var v = 0; v < num_vars; v++) { - tout << "#" << mk_pp(get_enode(v)->get_owner(), get_manager()) << " = " << m_assignment[v] << "\n"; + tout << "#" << mk_pp(get_enode(v)->get_owner(), m) << " = " << m_assignment[v] << "\n"; }); } @@ -811,11 +805,11 @@ namespace smt { enode * n = get_enode(v); if (m_autil.is_zero(n->get_owner()) && !m_assignment[v].is_zero()) { numeral val = m_assignment[v]; - sort * s = get_manager().get_sort(n->get_owner()); + sort * s = m.get_sort(n->get_owner()); // adjust the value of all variables that have the same sort. for (int v2 = 0; v2 < num_vars; ++v2) { enode * n2 = get_enode(v2); - if (get_manager().get_sort(n2->get_owner()) == s) { + if (m.get_sort(n2->get_owner()) == s) { m_assignment[v2] -= val; } } @@ -825,14 +819,14 @@ namespace smt { TRACE("ddl_model", tout << "ddl model\n"; for (theory_var v = 0; v < num_vars; v++) { - tout << "#" << mk_pp(get_enode(v)->get_owner(), get_manager()) << " = " << m_assignment[v] << "\n"; + tout << "#" << mk_pp(get_enode(v)->get_owner(), m) << " = " << m_assignment[v] << "\n"; }); } template - void theory_dense_diff_logic::init_model(model_generator & m) { - m_factory = alloc(arith_factory, get_manager()); - m.register_factory(m_factory); + void theory_dense_diff_logic::init_model(model_generator & mg) { + m_factory = alloc(arith_factory, m); + mg.register_factory(m_factory); if (!m_assignment.empty()) { fix_zero(); compute_epsilon(); @@ -880,7 +874,6 @@ namespace smt { return false; } else { - context& ctx = get_context(); enode * e = nullptr; theory_var v = 0; if (ctx.e_internalized(n)) { @@ -924,7 +917,6 @@ namespace smt { template inf_eps_rational theory_dense_diff_logic::maximize(theory_var v, expr_ref& blocker, bool& has_shared) { typedef simplex::simplex Simplex; - ast_manager& m = get_manager(); Simplex S(m.limit()); objective_term const& objective = m_objectives[v]; has_shared = false; @@ -1025,7 +1017,7 @@ namespace smt { unsigned edge_id = v - num_nodes; literal lit = m_edges[edge_id].m_justification; if (lit != null_literal) { - get_context().literal2expr(lit, tmp); + ctx.literal2expr(lit, tmp); core.push_back(tmp); } } @@ -1053,12 +1045,12 @@ namespace smt { template theory_var theory_dense_diff_logic::add_objective(app* term) { - TRACE("opt", tout << mk_pp(term, get_manager()) << "\n";); + TRACE("opt", tout << mk_pp(term, m) << "\n";); objective_term objective; theory_var result = m_objectives.size(); rational q(1), r(0); - expr_ref_vector vr(get_manager()); - if (!is_linear(get_manager(), term)) { + expr_ref_vector vr(m); + if (!is_linear(m, term)) { result = null_theory_var; } else if (internalize_objective(term, q, r, objective)) { @@ -1085,7 +1077,6 @@ namespace smt { template expr_ref theory_dense_diff_logic::mk_ineq(theory_var v, inf_eps const& val, bool is_strict) { - ast_manager& m = get_manager(); objective_term const& t = m_objectives[v]; expr_ref e(m), f(m), f2(m); TRACE("opt", tout << "mk_ineq " << v << " " << val << "\n";); diff --git a/src/smt/theory_diff_logic.h b/src/smt/theory_diff_logic.h index b47215ff0..df946be0a 100644 --- a/src/smt/theory_diff_logic.h +++ b/src/smt/theory_diff_logic.h @@ -226,26 +226,7 @@ namespace smt { void set_sort(expr* n); public: - theory_diff_logic(ast_manager& m, smt_params & params): - theory(m.mk_family_id("arith")), - m_params(params), - m_util(m), - m_arith_eq_adapter(*this, params, m_util), - m_consistent(true), - m_izero(null_theory_var), - m_rzero(null_theory_var), - m_terms(m), - m_asserted_qhead(0), - m_num_core_conflicts(0), - m_num_propagation_calls(0), - m_agility(0.5), - m_lia_or_lra(not_set), - m_non_diff_logic_exprs(false), - m_factory(nullptr), - m_nc_functor(*this), - m_S(m.limit()), - m_num_simplex_edges(0) { - } + theory_diff_logic(context& ctx); ~theory_diff_logic() override { reset_eh(); @@ -255,13 +236,13 @@ namespace smt { char const * get_name() const override { return "difference-logic"; } + void init() override { init_zero(); } + /** \brief See comment in theory::mk_eq_atom */ app * mk_eq_atom(expr * lhs, expr * rhs) override { return m_util.mk_eq(lhs, rhs); } - void init(context * ctx) override; - bool internalize_atom(app * atom, bool gate_ctx) override; bool internalize_term(app * term) override; diff --git a/src/smt/theory_diff_logic_def.h b/src/smt/theory_diff_logic_def.h index 1772c7f0b..b09a7a8ad 100644 --- a/src/smt/theory_diff_logic_def.h +++ b/src/smt/theory_diff_logic_def.h @@ -34,6 +34,28 @@ Revision History: using namespace smt; +template +theory_diff_logic::theory_diff_logic(context& ctx): + theory(ctx, ctx.get_manager().mk_family_id("arith")), + m_params(ctx.get_fparams()), + m_util(ctx.get_manager()), + m_arith_eq_adapter(*this, m_util), + m_consistent(true), + m_izero(null_theory_var), + m_rzero(null_theory_var), + m_terms(ctx.get_manager()), + m_asserted_qhead(0), + m_num_core_conflicts(0), + m_num_propagation_calls(0), + m_agility(0.5), + m_lia_or_lra(not_set), + m_non_diff_logic_exprs(false), + m_factory(nullptr), + m_nc_functor(*this), + m_S(ctx.get_manager().limit()), + m_num_simplex_edges(0) { +} + template std::ostream& theory_diff_logic::atom::display(theory_diff_logic const& th, std::ostream& out) const { context& ctx = th.get_context(); @@ -63,19 +85,13 @@ void theory_diff_logic::nc_functor::reset() { // ----------------------------------------- // theory_diff_logic -template -void theory_diff_logic::init(context * ctx) { - theory::init(ctx); - init_zero(); -} - template bool theory_diff_logic::internalize_term(app * term) { if (!m_consistent) return false; bool result = null_theory_var != mk_term(term); - CTRACE("arith", !result, tout << "Did not internalize " << mk_pp(term, get_manager()) << "\n";); + CTRACE("arith", !result, tout << "Did not internalize " << mk_pp(term, m) << "\n";); if (!result) { TRACE("non_diff_logic", tout << "Terms may not be internalized\n";); found_non_diff_logic_expr(term); @@ -154,9 +170,9 @@ public: template void theory_diff_logic::found_non_diff_logic_expr(expr * n) { if (!m_non_diff_logic_exprs) { - TRACE("non_diff_logic", tout << "found non diff logic expression:\n" << mk_pp(n, get_manager()) << "\n";); - IF_VERBOSE(0, verbose_stream() << "(smt.diff_logic: non-diff logic expression " << mk_pp(n, get_manager()) << ")\n";); - get_context().push_trail(value_trail(m_non_diff_logic_exprs)); + TRACE("non_diff_logic", tout << "found non diff logic expression:\n" << mk_pp(n, m) << "\n";); + IF_VERBOSE(0, verbose_stream() << "(smt.diff_logic: non-diff logic expression " << mk_pp(n, m) << ")\n";); + ctx.push_trail(value_trail(m_non_diff_logic_exprs)); m_non_diff_logic_exprs = true; } } @@ -165,7 +181,6 @@ template bool theory_diff_logic::internalize_atom(app * n, bool gate_ctx) { if (!m_consistent) return false; - context & ctx = get_context(); if (!m_util.is_le(n) && !m_util.is_ge(n)) { found_non_diff_logic_expr(n); return false; @@ -264,7 +279,7 @@ bool theory_diff_logic::internalize_atom(app * n, bool gate_ctx) { m_bool_var2atom.insert(bv, a); TRACE("arith", - tout << mk_pp(n, get_manager()) << "\n"; + tout << mk_pp(n, m) << "\n"; m_graph.display_edge(tout << "pos: ", pos); m_graph.display_edge(tout << "neg: ", neg); ); @@ -274,8 +289,7 @@ bool theory_diff_logic::internalize_atom(app * n, bool gate_ctx) { template void theory_diff_logic::internalize_eq_eh(app * atom, bool_var v) { - context & ctx = get_context(); - TRACE("arith", tout << mk_pp(atom, get_manager()) << "\n";); + TRACE("arith", tout << mk_pp(atom, m) << "\n";); app * lhs = to_app(atom->get_arg(0)); app * rhs = to_app(atom->get_arg(1)); app * s; @@ -303,8 +317,8 @@ void theory_diff_logic::assign_eh(bool_var v, bool is_true) { atom * a = nullptr; VERIFY (m_bool_var2atom.find(v, a)); SASSERT(a); - SASSERT(get_context().get_assignment(v) != l_undef); - SASSERT((get_context().get_assignment(v) == l_true) == is_true); + SASSERT(ctx.get_assignment(v) != l_undef); + SASSERT((ctx.get_assignment(v) == l_true) == is_true); a->assign_eh(is_true); m_asserted_atoms.push_back(a); } @@ -370,12 +384,12 @@ final_check_status theory_diff_logic::final_check_eh() { return FC_GIVEUP; } - for (enode* n : get_context().enodes()) { + for (enode* n : ctx.enodes()) { family_id fid = n->get_owner()->get_family_id(); if (fid != get_family_id() && - fid != get_manager().get_basic_family_id() && + fid != m.get_basic_family_id() && !is_uninterp_const(n->get_owner())) { - TRACE("arith", tout << mk_pp(n->get_owner(), get_manager()) << "\n";); + TRACE("arith", tout << mk_pp(n->get_owner(), m) << "\n";); return FC_GIVEUP; } } @@ -410,7 +424,7 @@ bool theory_diff_logic::decompose_linear(app_ref_vector& terms, bool_vector if (m_util.is_add(n)) { expr* arg = n->get_arg(0); if (!is_app(arg)) return false; - expr_ref _n(n, get_manager()); + expr_ref _n(n, m); terms[i] = to_app(arg); sign = signs[i]; for (unsigned j = 1; j < n->get_num_args(); ++j) { @@ -503,7 +517,7 @@ void theory_diff_logic::propagate() { ++m_num_propagation_calls; if (m_num_propagation_calls * (m_stats.m_num_conflicts + 1) > - m_params.m_arith_adaptive_propagation_threshold * get_context().m_stats.m_num_conflicts) { + m_params.m_arith_adaptive_propagation_threshold * ctx.m_stats.m_num_conflicts) { m_num_propagation_calls = 1; TRACE("arith_prop", tout << "propagating: " << m_num_propagation_calls << "\n";); propagate_core(); @@ -517,7 +531,7 @@ void theory_diff_logic::propagate() { // update agility with factor generated by other conflicts. double g = m_params.m_arith_adaptive_propagation_threshold; - while (m_num_core_conflicts < get_context().m_stats.m_num_conflicts) { + while (m_num_core_conflicts < ctx.m_stats.m_num_conflicts) { m_agility = m_agility*g; ++m_num_core_conflicts; } @@ -544,7 +558,7 @@ void theory_diff_logic::propagate() { template void theory_diff_logic::inc_conflicts() { - get_context().push_trail(value_trail(m_consistent)); + ctx.push_trail(value_trail(m_consistent)); m_consistent = false; m_stats.m_num_conflicts++; if (m_params.m_arith_adaptive) { @@ -565,7 +579,6 @@ void theory_diff_logic::propagate_core() { template bool theory_diff_logic::propagate_atom(atom* a) { - context& ctx = get_context(); TRACE("arith", a->display(*this, tout); tout << "\n";); if (ctx.inconsistent()) { return false; @@ -589,7 +602,6 @@ void theory_diff_logic::new_edge(dl_var src, dl_var dst, unsigned num_edges TRACE("dl_activity", tout << "\n";); - context& ctx = get_context(); numeral w(0); for (unsigned i = 0; i < num_edges; ++i) { w += m_graph.get_weight(edges[i]); @@ -601,7 +613,7 @@ void theory_diff_logic::new_edge(dl_var src, dl_var dst, unsigned num_edges bool is_int = m_util.is_int(n1); rational num = w.get_rational().to_rational(); - expr_ref le(get_manager()); + expr_ref le(m); if (w.is_rational()) { // x - y <= w expr* n3 = m_util.mk_numeral(num, is_int); @@ -619,11 +631,11 @@ void theory_diff_logic::new_edge(dl_var src, dl_var dst, unsigned num_edges expr* n3 = m_util.mk_numeral(-num, is_int); n1 = m_util.mk_mul(m_util.mk_numeral(rational(-1), is_int), n1); le = m_util.mk_le(m_util.mk_add(n2,n1), n3); - le = get_manager().mk_not(le); + le = m.mk_not(le); } - if (get_manager().has_trace_stream())log_axiom_instantiation(le); + if (m.has_trace_stream())log_axiom_instantiation(le); ctx.internalize(le, false); - if (get_manager().has_trace_stream()) get_manager().trace_stream() << "[end-of-instance]\n"; + if (m.has_trace_stream()) m.trace_stream() << "[end-of-instance]\n"; ctx.mark_as_relevant(le.get()); literal lit(ctx.get_literal(le)); bool_var bv = lit.var(); @@ -638,14 +650,14 @@ void theory_diff_logic::new_edge(dl_var src, dl_var dst, unsigned num_edges lits.push_back(lit); TRACE("dl_activity", - tout << mk_pp(le, get_manager()) << "\n"; + tout << mk_pp(le, m) << "\n"; tout << "edge: " << a->get_pos() << "\n"; ctx.display_literals_verbose(tout, lits.size(), lits.c_ptr()); tout << "\n"; ); justification * js = nullptr; - if (get_manager().proofs_enabled()) { + if (m.proofs_enabled()) { vector params; params.push_back(parameter(symbol("farkas"))); params.resize(lits.size()+1, parameter(rational(1))); @@ -691,7 +703,6 @@ void theory_diff_logic::set_neg_cycle_conflict() { m_graph.traverse_neg_cycle2(m_params.m_arith_stronger_lemmas, m_nc_functor); inc_conflicts(); literal_vector const& lits = m_nc_functor.get_lits(); - context & ctx = get_context(); TRACE("arith_conflict", tout << "conflict: "; for (literal lit : lits) ctx.display_literal_info(tout, lit); @@ -703,7 +714,7 @@ void theory_diff_logic::set_neg_cycle_conflict() { } vector params; - if (get_manager().proofs_enabled()) { + if (m.proofs_enabled()) { params.push_back(parameter(symbol("farkas"))); for (unsigned i = 0; i <= lits.size(); ++i) { params.push_back(parameter(rational(1))); @@ -744,9 +755,8 @@ theory_var theory_diff_logic::mk_term(app* n) { app* a, *offset; theory_var source, target; enode* e; - context& ctx = get_context(); - TRACE("arith", tout << mk_pp(n, get_manager()) << "\n";); + TRACE("arith", tout << mk_pp(n, m) << "\n";); rational r; if (m_util.is_numeral(n, r)) { @@ -761,7 +771,7 @@ theory_var theory_diff_logic::mk_term(app* n) { ctx.internalize(arg, false); } } - e = get_context().mk_enode(n, false, false, true); + e = ctx.mk_enode(n, false, false, true); target = mk_var(e); numeral k(r); // target - source <= k, source - target <= -k @@ -782,7 +792,6 @@ template theory_var theory_diff_logic::mk_num(app* n, rational const& r) { theory_var v = null_theory_var; enode* e = nullptr; - context& ctx = get_context(); if (r.is_zero()) { v = get_zero(m_util.is_int(n)); } @@ -812,7 +821,7 @@ theory_var theory_diff_logic::mk_var(enode* n) { theory_var v = theory::mk_var(n); TRACE("diff_logic_vars", tout << "mk_var: " << v << "\n";); m_graph.init_var(v); - get_context().attach_th_var(n, this, v); + ctx.attach_th_var(n, this, v); set_sort(n->get_owner()); return v; } @@ -838,7 +847,6 @@ void theory_diff_logic::set_sort(expr* n) { template theory_var theory_diff_logic::mk_var(app* n) { - context & ctx = get_context(); enode* e = nullptr; theory_var v = null_theory_var; if (!ctx.e_internalized(n)) { @@ -854,7 +862,7 @@ theory_var theory_diff_logic::mk_var(app* n) { TRACE("non_diff_logic", tout << "Variable should not be interpreted\n";); found_non_diff_logic_expr(n); } - TRACE("arith", tout << mk_pp(n, get_manager()) << " |-> " << v << "\n";); + TRACE("arith", tout << mk_pp(n, m) << " |-> " << v << "\n";); return v; } @@ -935,7 +943,7 @@ model_value_proc * theory_diff_logic::mk_value(enode * n, model_generator & numeral val = m_graph.get_assignment(v); num = val.get_rational().to_rational() + m_delta * val.get_infinitesimal().to_rational(); } - TRACE("arith", tout << mk_pp(n->get_owner(), get_manager()) << " |-> " << num << "\n";); + TRACE("arith", tout << mk_pp(n->get_owner(), m) << " |-> " << num << "\n";); bool is_int = m_util.is_int(n->get_owner()); if (is_int && !num.is_int()) throw default_exception("difference logic solver was used on mixed int/real problem"); @@ -956,7 +964,6 @@ void theory_diff_logic::display(std::ostream & out) const { template bool theory_diff_logic::is_consistent() const { DEBUG_CODE( - context& ctx = get_context(); for (unsigned i = 0; m_graph.is_feasible_dbg() && i < m_atoms.size(); ++i) { atom* a = m_atoms[i]; bool_var bv = a->get_bool_var(); @@ -974,7 +981,6 @@ bool theory_diff_logic::is_consistent() const { template theory_var theory_diff_logic::expand(bool pos, theory_var v, rational & k) { - context& ctx = get_context(); enode* e = get_enode(v); rational r; for (;;) { @@ -1012,8 +1018,6 @@ void theory_diff_logic::new_eq_or_diseq(bool is_eq, theory_var v1, theory_v rational k; theory_var s = expand(true, v1, k); theory_var t = expand(false, v2, k); - context& ctx = get_context(); - ast_manager& m = get_manager(); if (s == t) { if (is_eq != k.is_zero()) { @@ -1050,7 +1054,7 @@ void theory_diff_logic::new_eq_or_diseq(bool is_eq, theory_var v1, theory_v UNREACHABLE(); } - if (m.has_trace_stream()) get_manager().trace_stream() << "[end-of-instance]\n"; + if (m.has_trace_stream()) m.trace_stream() << "[end-of-instance]\n"; literal l(ctx.get_literal(eq.get())); if (!is_eq) { @@ -1238,7 +1242,6 @@ theory_diff_logic::maximize(theory_var v, expr_ref& blocker, bool& has_shar has_shared = false; Simplex& S = m_S; - ast_manager& m = get_manager(); CTRACE("arith",!m_graph.is_feasible_dbg(), m_graph.display(tout);); SASSERT(m_graph.is_feasible_dbg()); @@ -1286,7 +1289,7 @@ theory_diff_logic::maximize(theory_var v, expr_ref& blocker, bool& has_shar unsigned edge_id = simplex2edge(v); literal lit = m_graph.get_explanation(edge_id); if (lit != null_literal) { - get_context().literal2expr(lit, tmp); + ctx.literal2expr(lit, tmp); core.push_back(tmp); } } @@ -1322,8 +1325,8 @@ theory_var theory_diff_logic::add_objective(app* term) { objective_term objective; theory_var result = m_objectives.size(); rational q(1), r(0); - expr_ref_vector vr(get_manager()); - if (!is_linear(get_manager(), term)) { + expr_ref_vector vr(m); + if (!is_linear(m, term)) { result = null_theory_var; } else if (internalize_objective(term, q, r, objective)) { @@ -1339,7 +1342,6 @@ theory_var theory_diff_logic::add_objective(app* term) { template expr_ref theory_diff_logic::mk_ineq(theory_var v, inf_eps const& val, bool is_strict) { - ast_manager& m = get_manager(); objective_term const& t = m_objectives[v]; expr_ref e(m), f(m), f2(m); if (t.size() == 1 && t[0].second.is_one()) { @@ -1402,11 +1404,9 @@ expr_ref theory_diff_logic::mk_ge(generic_model_converter& fm, theory_var v } #if 0 - context & ctx = get_context(); model_ref mdl; ctx.get_model(mdl); ptr_vector formulas(ctx.get_num_asserted_formulas(), ctx.get_asserted_formulas()); - ast_manager& m = get_manager(); model_implicant impl_extractor(m); expr_ref_vector implicants = impl_extractor.minimize_literals(formulas, mdl); return m.mk_and(o, m.mk_not(m.mk_and(implicants.size(), implicants.c_ptr()))); @@ -1449,14 +1449,13 @@ bool theory_diff_logic::internalize_objective(expr * n, rational const& m, template theory* theory_diff_logic::mk_fresh(context* new_ctx) { - return alloc(theory_diff_logic, new_ctx->get_manager(), new_ctx->get_fparams()); + return alloc(theory_diff_logic, *new_ctx); } template void theory_diff_logic::init_zero() { if (m_izero != null_theory_var) return; TRACE("arith", tout << "init zero\n";); - context & ctx = get_context(); app* zero; enode* e; zero = m_util.mk_numeral(rational(0), true); diff --git a/src/smt/theory_dl.cpp b/src/smt/theory_dl.cpp index 37217ae01..0d4b89f35 100644 --- a/src/smt/theory_dl.cpp +++ b/src/smt/theory_dl.cpp @@ -102,11 +102,11 @@ namespace smt { }; public: - theory_dl(ast_manager& m): - theory(m.mk_family_id("datalog_relation")), - m_util(m), - m_bv(m), - m_trail(m) + theory_dl(context& ctx): + theory(ctx, ctx.get_manager().mk_family_id("datalog_relation")), + m_util(ctx.get_manager()), + m_bv(ctx.get_manager()), + m_trail(ctx.get_manager()) { } @@ -115,7 +115,6 @@ namespace smt { bool internalize_atom(app * atom, bool gate_ctx) override { TRACE("theory_dl", tout << mk_pp(atom, m()) << "\n";); - context& ctx = get_context(); if (ctx.b_internalized(atom)) { return true; } @@ -155,7 +154,7 @@ namespace smt { } theory * mk_fresh(context * new_ctx) override { - return alloc(theory_dl, new_ctx->get_manager()); + return alloc(theory_dl, *new_ctx); } void init_model(smt::model_generator & m) override { @@ -210,13 +209,12 @@ namespace smt { m_vals.insert(s, v); add_trail(r); add_trail(v); - get_context().push_trail(insert_obj_map(m_reps, s)); - get_context().push_trail(insert_obj_map(m_vals, s)); + ctx.push_trail(insert_obj_map(m_reps, s)); + ctx.push_trail(insert_obj_map(m_vals, s)); } } bool mk_rep(app* n) { - context & ctx = get_context(); unsigned num_args = n->get_num_args(); enode * e = nullptr; for (unsigned i = 0; i < num_args; i++) { @@ -255,7 +253,6 @@ namespace smt { app_ref lt(m()), le(m()); lt = u().mk_lt(x,y); le = b().mk_ule(m().mk_app(r,y),m().mk_app(r,x)); - context& ctx = get_context(); if (m().has_trace_stream()) { app_ref body(m()); body = m().mk_eq(lt, le); @@ -276,7 +273,6 @@ namespace smt { void assert_cnstr(expr* e) { TRACE("theory_dl", tout << mk_pp(e, m()) << "\n";); - context& ctx = get_context(); if (m().has_trace_stream()) log_axiom_instantiation(e); ctx.internalize(e, false); if (m().has_trace_stream()) m().trace_stream() << "[end-of-instance]\n"; @@ -287,11 +283,11 @@ namespace smt { void add_trail(ast* a) { m_trail.push_back(a); - get_context().push_trail(push_back_vector(m_trail)); + ctx.push_trail(push_back_vector(m_trail)); } }; - theory* mk_theory_dl(ast_manager& m) { return alloc(theory_dl, m); } + theory* mk_theory_dl(context& ctx) { return alloc(theory_dl, ctx); } }; diff --git a/src/smt/theory_dl.h b/src/smt/theory_dl.h index be9539af5..57aef16e6 100644 --- a/src/smt/theory_dl.h +++ b/src/smt/theory_dl.h @@ -22,7 +22,7 @@ Revision History: namespace smt { - theory* mk_theory_dl(ast_manager& m); + theory* mk_theory_dl(context& ctx); }; diff --git a/src/smt/theory_dummy.cpp b/src/smt/theory_dummy.cpp index d1695134e..938237a90 100644 --- a/src/smt/theory_dummy.cpp +++ b/src/smt/theory_dummy.cpp @@ -29,8 +29,8 @@ namespace smt { } } - theory_dummy::theory_dummy(family_id fid, char const * name): - theory(fid), + theory_dummy::theory_dummy(context& ctx, family_id fid, char const * name): + theory(ctx, fid), m_theory_exprs(false), m_name(name) { } diff --git a/src/smt/theory_dummy.h b/src/smt/theory_dummy.h index c58695aac..9d2bfcddb 100644 --- a/src/smt/theory_dummy.h +++ b/src/smt/theory_dummy.h @@ -46,10 +46,10 @@ namespace smt { void display(std::ostream& out) const override {} public: - theory_dummy(family_id fid, char const * name); + theory_dummy(context& ctx, family_id fid, char const * name); ~theory_dummy() override {} - theory * mk_fresh(context * new_ctx) override { return alloc(theory_dummy, get_family_id(), m_name); } + theory * mk_fresh(context * new_ctx) override { return alloc(theory_dummy, *new_ctx, get_family_id(), m_name); } char const * get_name() const override; }; diff --git a/src/smt/theory_fpa.cpp b/src/smt/theory_fpa.cpp index bf2ec987a..4da4b3350 100644 --- a/src/smt/theory_fpa.cpp +++ b/src/smt/theory_fpa.cpp @@ -84,20 +84,20 @@ namespace smt { } } - theory_fpa::theory_fpa(ast_manager & m) : - theory(m.mk_family_id("fpa")), - m_converter(m, this), - m_rw(m, m_converter, params_ref()), - m_th_rw(m), + theory_fpa::theory_fpa(context& ctx) : + theory(ctx, ctx.get_manager().mk_family_id("fpa")), + m_converter(ctx.get_manager(), this), + m_rw(ctx.get_manager(), m_converter, params_ref()), + m_th_rw(ctx.get_manager()), m_trail_stack(*this), m_fpa_util(m_converter.fu()), m_bv_util(m_converter.bu()), m_arith_util(m_converter.au()), - m_is_initialized(false) + m_is_initialized(true) { params_ref p; p.set_bool("arith_lhs", true); - m_th_rw.updt_params(p); + m_th_rw.updt_params(p); } theory_fpa::~theory_fpa() @@ -105,7 +105,6 @@ namespace smt { m_trail_stack.reset(); if (m_is_initialized) { - ast_manager & m = get_manager(); dec_ref_map_key_values(m, m_conversions); dec_ref_collection_values(m, m_is_added_to_model); @@ -120,11 +119,6 @@ namespace smt { SASSERT(m_is_added_to_model.empty()); } - void theory_fpa::init(context * ctx) { - smt::theory::init(ctx); - m_is_initialized = true; - } - app * theory_fpa::fpa_value_proc::mk_value(model_generator & mg, expr_ref_vector const & values) { TRACE("t_fpa_detail", ast_manager & m = m_th.get_manager(); @@ -233,7 +227,6 @@ namespace smt { app_ref theory_fpa::wrap(expr * e) { SASSERT(m_fpa_util.is_float(e) || m_fpa_util.is_rm(e)); SASSERT(!m_fpa_util.is_bvwrap(e)); - ast_manager & m = get_manager(); app_ref res(m); if (m_fpa_util.is_fp(e)) { @@ -267,7 +260,6 @@ namespace smt { SASSERT(!m_fpa_util.is_fp(e)); SASSERT(m_bv_util.is_bv(e)); SASSERT(m_fpa_util.is_float(s) || m_fpa_util.is_rm(s)); - ast_manager & m = get_manager(); app_ref res(m); unsigned bv_sz = m_bv_util.get_bv_size(e); @@ -293,8 +285,7 @@ namespace smt { } expr_ref theory_fpa::convert_atom(expr * e) { - ast_manager & m = get_manager(); - TRACE("t_fpa_detail", tout << "converting atom: " << mk_ismt2_pp(e, get_manager()) << std::endl;); + TRACE("t_fpa_detail", tout << "converting atom: " << mk_ismt2_pp(e, m) << std::endl;); expr_ref res(m); proof_ref pr(m); m_rw(e, res); @@ -306,15 +297,14 @@ namespace smt { expr_ref theory_fpa::convert_term(expr * e) { SASSERT(m_fpa_util.is_rm(e) || m_fpa_util.is_float(e)); - ast_manager & m = get_manager(); expr_ref e_conv(m), res(m); proof_ref pr(m); m_rw(e, e_conv); - TRACE("t_fpa_detail", tout << "term: " << mk_ismt2_pp(e, get_manager()) << std::endl; - tout << "converted term: " << mk_ismt2_pp(e_conv, get_manager()) << std::endl;); + TRACE("t_fpa_detail", tout << "term: " << mk_ismt2_pp(e, m) << std::endl; + tout << "converted term: " << mk_ismt2_pp(e_conv, m) << std::endl;); if (m_fpa_util.is_rm(e)) { SASSERT(m_fpa_util.is_bv2rm(e_conv)); @@ -340,7 +330,7 @@ namespace smt { expr_ref theory_fpa::convert_conversion_term(expr * e) { SASSERT(to_app(e)->get_family_id() == get_family_id()); /* This is for the conversion functions fp.to_* */ - expr_ref res(get_manager()); + expr_ref res(m); m_rw(e, res); m_th_rw(res, res); return res; @@ -348,7 +338,6 @@ namespace smt { expr_ref theory_fpa::convert(expr * e) { - ast_manager & m = get_manager(); expr_ref res(m); expr * ccnv; TRACE("t_fpa", tout << "converting " << mk_ismt2_pp(e, m) << std::endl;); @@ -384,8 +373,6 @@ namespace smt { expr_ref theory_fpa::mk_side_conditions() { - ast_manager & m = get_manager(); - context & ctx = get_context(); expr_ref res(m), t(m); expr_ref_vector fmls(m); @@ -405,31 +392,26 @@ namespace smt { } void theory_fpa::assert_cnstr(expr * e) { - if (get_manager().is_true(e)) return; - TRACE("t_fpa_detail", tout << "asserting " << mk_ismt2_pp(e, get_manager()) << "\n";); - context & ctx = get_context(); - if (get_manager().has_trace_stream()) log_axiom_instantiation(e); + if (m.is_true(e)) return; + TRACE("t_fpa_detail", tout << "asserting " << mk_ismt2_pp(e, m) << "\n";); + if (m.has_trace_stream()) log_axiom_instantiation(e); ctx.internalize(e, false); - if (get_manager().has_trace_stream()) get_manager().trace_stream() << "[end-of-instance]\n"; + if (m.has_trace_stream()) m.trace_stream() << "[end-of-instance]\n"; literal lit(ctx.get_literal(e)); ctx.mark_as_relevant(lit); ctx.mk_th_axiom(get_id(), 1, &lit); } void theory_fpa::attach_new_th_var(enode * n) { - context & ctx = get_context(); theory_var v = mk_var(n); ctx.attach_th_var(n, this, v); - TRACE("t_fpa", tout << "new theory var: " << mk_ismt2_pp(n->get_owner(), get_manager()) << " := " << v << "\n";); + TRACE("t_fpa", tout << "new theory var: " << mk_ismt2_pp(n->get_owner(), m) << " := " << v << "\n";); } bool theory_fpa::internalize_atom(app * atom, bool gate_ctx) { - TRACE("t_fpa_internalize", tout << "internalizing atom: " << mk_ismt2_pp(atom, get_manager()) << std::endl;); + TRACE("t_fpa_internalize", tout << "internalizing atom: " << mk_ismt2_pp(atom, m) << std::endl;); SASSERT(atom->get_family_id() == get_family_id()); - ast_manager & m = get_manager(); - context & ctx = get_context(); - if (ctx.b_internalized(atom)) return true; @@ -450,12 +432,9 @@ namespace smt { } bool theory_fpa::internalize_term(app * term) { - TRACE("t_fpa_internalize", tout << "internalizing term: " << mk_ismt2_pp(term, get_manager()) << "\n";); + TRACE("t_fpa_internalize", tout << "internalizing term: " << mk_ismt2_pp(term, m) << "\n";); SASSERT(term->get_family_id() == get_family_id()); - SASSERT(!get_context().e_internalized(term)); - - ast_manager & m = get_manager(); - context & ctx = get_context(); + SASSERT(!ctx.e_internalized(term)); unsigned num_args = term->get_num_args(); for (unsigned i = 0; i < num_args; i++) @@ -493,14 +472,12 @@ namespace smt { } void theory_fpa::apply_sort_cnstr(enode * n, sort * s) { - TRACE("t_fpa", tout << "apply sort cnstr for: " << mk_ismt2_pp(n->get_owner(), get_manager()) << "\n";); + TRACE("t_fpa", tout << "apply sort cnstr for: " << mk_ismt2_pp(n->get_owner(), m) << "\n";); SASSERT(s->get_family_id() == get_family_id()); SASSERT(m_fpa_util.is_float(s) || m_fpa_util.is_rm(s)); SASSERT(m_fpa_util.is_float(n->get_owner()) || m_fpa_util.is_rm(n->get_owner())); SASSERT(n->get_owner()->get_decl()->get_range() == s); - ast_manager & m = get_manager(); - context & ctx = get_context(); app_ref owner(n->get_owner(), m); if (!is_attached_to_var(n)) { @@ -523,7 +500,6 @@ namespace smt { } void theory_fpa::new_eq_eh(theory_var x, theory_var y) { - ast_manager & m = get_manager(); enode * e_x = get_enode(x); enode * e_y = get_enode(y); @@ -567,7 +543,6 @@ namespace smt { } void theory_fpa::new_diseq_eh(theory_var x, theory_var y) { - ast_manager & m = get_manager(); enode * e_x = get_enode(x); enode * e_y = get_enode(y); @@ -614,7 +589,7 @@ namespace smt { } theory* theory_fpa::mk_fresh(context* new_ctx) { - return alloc(theory_fpa, new_ctx->get_manager()); + return alloc(theory_fpa, *new_ctx); } void theory_fpa::push_scope_eh() { @@ -629,8 +604,6 @@ namespace smt { } void theory_fpa::assign_eh(bool_var v, bool is_true) { - ast_manager & m = get_manager(); - context & ctx = get_context(); expr * e = ctx.bool_var2expr(v); TRACE("t_fpa", tout << "assign_eh for: " << v << " (" << is_true << "):\n" << mk_ismt2_pp(e, m) << "\n";); @@ -645,7 +618,6 @@ namespace smt { } void theory_fpa::relevant_eh(app * n) { - ast_manager & m = get_manager(); TRACE("t_fpa", tout << "relevant_eh for: " << mk_ismt2_pp(n, m) << "\n";); mpf_manager & mpfm = m_fpa_util.fm(); @@ -678,7 +650,7 @@ namespace smt { else { expr_ref wu(m); wu = m.mk_eq(unwrap(wrapped, m.get_sort(n)), n); - TRACE("t_fpa", tout << "w/u eq: " << std::endl << mk_ismt2_pp(wu, get_manager()) << std::endl;); + TRACE("t_fpa", tout << "w/u eq: " << std::endl << mk_ismt2_pp(wu, m) << std::endl;); assert_cnstr(wu); } } @@ -709,7 +681,6 @@ namespace smt { dealloc(m_factory); m_factory = nullptr; } - ast_manager & m = get_manager(); dec_ref_map_key_values(m, m_conversions); dec_ref_collection_values(m, m_is_added_to_model); theory::reset_eh(); @@ -723,13 +694,11 @@ namespace smt { void theory_fpa::init_model(model_generator & mg) { TRACE("t_fpa", tout << "initializing model" << std::endl; display(tout);); - ast_manager & m = get_manager(); m_factory = alloc(fpa_value_factory, m, get_family_id()); mg.register_factory(m_factory); } enode* theory_fpa::ensure_enode(expr* e) { - context& ctx = get_context(); if (!ctx.e_internalized(e)) { ctx.internalize(e, false); } @@ -739,8 +708,6 @@ namespace smt { } app* theory_fpa::get_ite_value(expr* e) { - ast_manager & m = get_manager(); - context& ctx = get_context(); expr* e1, *e2, *e3; while (m.is_ite(e, e1, e2, e3) && ctx.e_internalized(e)) { if (ctx.get_enode(e2)->get_root() == ctx.get_enode(e)->get_root()) { @@ -757,11 +724,9 @@ namespace smt { } model_value_proc * theory_fpa::mk_value(enode * n, model_generator & mg) { - TRACE("t_fpa", tout << "mk_value for: " << mk_ismt2_pp(n->get_owner(), get_manager()) << - " (sort " << mk_ismt2_pp(get_manager().get_sort(n->get_owner()), get_manager()) << ")\n";); + TRACE("t_fpa", tout << "mk_value for: " << mk_ismt2_pp(n->get_owner(), m) << + " (sort " << mk_ismt2_pp(m.get_sort(n->get_owner()), m) << ")\n";); - ast_manager & m = get_manager(); - context & ctx = get_context(); app_ref owner(m); owner = get_ite_value(n->get_owner()); @@ -840,7 +805,6 @@ namespace smt { } void theory_fpa::finalize_model(model_generator & mg) { - ast_manager & m = get_manager(); proto_model & mdl = mg.get_model(); proto_model new_model(m); @@ -869,8 +833,6 @@ namespace smt { void theory_fpa::display(std::ostream & out) const { - ast_manager & m = get_manager(); - context & ctx = get_context(); bool first = true; for (enode* n : ctx.enodes()) { diff --git a/src/smt/theory_fpa.h b/src/smt/theory_fpa.h index aa95dd2e0..f1c496962 100644 --- a/src/smt/theory_fpa.h +++ b/src/smt/theory_fpa.h @@ -177,11 +177,9 @@ namespace smt { void finalize_model(model_generator & mg) override; public: - theory_fpa(ast_manager & m); + theory_fpa(context& ctx); ~theory_fpa() override; - void init(context * ctx) override; - void display(std::ostream & out) const override; protected: diff --git a/src/smt/theory_jobscheduler.cpp b/src/smt/theory_jobscheduler.cpp index cf5d0b49e..8684e65d0 100644 --- a/src/smt/theory_jobscheduler.cpp +++ b/src/smt/theory_jobscheduler.cpp @@ -55,7 +55,6 @@ namespace smt { } bool theory_jobscheduler::internalize_term(app * term) { - context & ctx = get_context(); if (ctx.e_internalized(term)) return true; for (expr* arg : *term) { @@ -71,7 +70,6 @@ namespace smt { bool theory_jobscheduler::internalize_atom(app * atom, bool gate_ctx) { TRACE("csp", tout << mk_pp(atom, m) << "\n";); - context & ctx = get_context(); SASSERT(u.is_model(atom)); for (expr* arg : *atom) { if (!ctx.e_internalized(arg)) ctx.internalize(arg, false); @@ -199,7 +197,6 @@ namespace smt { literal theory_jobscheduler::mk_literal(expr * e) { expr_ref _e(e, m); - context& ctx = get_context(); if (!ctx.e_internalized(e)) { ctx.internalize(e, false); } @@ -228,7 +225,6 @@ namespace smt { } literal theory_jobscheduler::mk_le(enode* l, enode* r) { - context& ctx = get_context(); expr_ref le(a.mk_le(l->get_owner(), r->get_owner()), m); ctx.get_rewriter()(le); return mk_literal(le); @@ -240,7 +236,7 @@ namespace smt { literal theory_jobscheduler::mk_eq_lit(expr * l, expr * r) { literal lit = mk_eq(l, r, false); - get_context().mark_as_relevant(lit); + ctx.mark_as_relevant(lit); return lit; } @@ -290,7 +286,6 @@ namespace smt { void theory_jobscheduler::propagate_end_time(unsigned j, unsigned r) { time_t slb = est(j); time_t clb = ect(j, r, slb); - context& ctx = get_context(); if (clb > end(j)) { job_info const& ji = m_jobs[j]; @@ -384,7 +379,6 @@ namespace smt { lits.push_back(~mk_le(start_e, t1)); expr_ref rhs(a.mk_add(start_e->get_owner(), a.mk_int(rational(delta, rational::ui64()))), m); lits.push_back(mk_eq_lit(end_e->get_owner(), rhs)); - context& ctx = get_context(); ctx.mk_clause(lits.size(), lits.c_ptr(), nullptr, CLS_TH_LEMMA, nullptr); ast_manager& m = get_manager(); if (m.has_trace_stream()) { @@ -457,7 +451,6 @@ namespace smt { } if (j == last_job) break; } - context& ctx = get_context(); ctx.mk_clause(lits.size(), lits.c_ptr(), nullptr, CLS_TH_LEMMA, nullptr); } @@ -503,9 +496,9 @@ namespace smt { } } - theory_jobscheduler::theory_jobscheduler(ast_manager& m): - theory(m.get_family_id("csp")), - m(m), + theory_jobscheduler::theory_jobscheduler(context& ctx): + theory(ctx, ctx.get_manager().get_family_id("csp")), + m(ctx.get_manager()), u(m), a(m), m_bound_qhead(0) { @@ -576,7 +569,7 @@ namespace smt { } theory * theory_jobscheduler::mk_fresh(context * new_ctx) { - return alloc(theory_jobscheduler, new_ctx->get_manager()); + return alloc(theory_jobscheduler, *new_ctx); } time_t theory_jobscheduler::get_lo(expr* e) { @@ -657,7 +650,6 @@ namespace smt { unsigned r = m_resources.size(); m_resources.push_back(res_info()); res_info& ri = m_resources.back(); - context& ctx = get_context(); app_ref res(u.mk_resource(r), m); if (!ctx.e_internalized(res)) ctx.internalize(res, false); ri.m_resource = ctx.get_enode(res); @@ -673,7 +665,6 @@ namespace smt { unsigned j = m_jobs.size(); m_jobs.push_back(job_info()); job_info& ji = m_jobs.back(); - context& ctx = get_context(); app_ref job(u.mk_job(j), m); app_ref start(u.mk_start(j), m); app_ref end(u.mk_end(j), m); @@ -691,7 +682,7 @@ namespace smt { } void theory_jobscheduler::add_job_resource(unsigned j, unsigned r, unsigned loadpct, uint64_t cap, time_t finite_capacity_end, properties const& ps) { - SASSERT(get_context().at_base_level()); + SASSERT(ctx.at_base_level()); SASSERT(0 <= loadpct && loadpct <= 100); SASSERT(0 <= cap); job_info& ji = ensure_job(j); @@ -707,7 +698,7 @@ namespace smt { void theory_jobscheduler::add_resource_available(unsigned r, unsigned max_loadpct, time_t start, time_t end, properties const& ps) { - SASSERT(get_context().at_base_level()); + SASSERT(ctx.at_base_level()); SASSERT(1 <= max_loadpct && max_loadpct <= 100); SASSERT(start <= end); res_info& ri = ensure_resource(r); @@ -731,7 +722,6 @@ namespace smt { */ void theory_jobscheduler::add_done() { TRACE("csp", tout << "add-done begin\n";); - context & ctx = get_context(); // sort availability intervals for (res_info& ri : m_resources) { @@ -819,7 +809,6 @@ namespace smt { #if 0 job_info const& ji = m_jobs[j]; literal l2 = mk_le(ji.m_end, jr.m_finite_capacity_end); - context& ctx = get_context(); if (m.has_trace_stream()) { app_ref body(m); body = m.mk_implies(ctx.bool_var2expr(eq.var()), ctx.bool_var2expr(l2.var())); @@ -832,7 +821,6 @@ namespace smt { // resource(j) = r => start(j) <= lst(j, r, end(j, r)) void theory_jobscheduler::assert_last_start_time(unsigned j, unsigned r, literal eq) { - context& ctx = get_context(); time_t t; if (lst(j, r, t)) { literal le = mk_le(m_jobs[j].m_start, t); @@ -863,7 +851,6 @@ namespace smt { if (!first_available(jr, m_resources[r], idx)) return; vector& available = m_resources[r].m_available; literal l2 = mk_ge(m_jobs[j].m_start, available[idx].m_start); - context& ctx = get_context(); if (m.has_trace_stream()) { app_ref body(m); body = m.mk_implies(ctx.bool_var2expr(eq.var()), ctx.bool_var2expr(l2.var())); @@ -881,7 +868,6 @@ namespace smt { SASSERT(resource_available(jr, available[idx])); literal l2 = mk_ge(m_jobs[j].m_start, available[idx1].m_start); literal l3 = mk_le(m_jobs[j].m_start, available[idx].m_end); - context& ctx = get_context(); if (m.has_trace_stream()) { app_ref body(m); body = m.mk_implies(ctx.bool_var2expr(eq.var()), m.mk_or(ctx.bool_var2expr(l2.var()), ctx.bool_var2expr(l3.var()))); @@ -899,7 +885,6 @@ namespace smt { SASSERT(resource_available(jr, available[idx])); literal l2 = mk_le(m_jobs[j].m_end, available[idx].m_end); literal l3 = mk_ge(m_jobs[j].m_start, available[idx1].m_start); - context& ctx = get_context(); if (m.has_trace_stream()) { app_ref body(m); body = m.mk_implies(ctx.bool_var2expr(eq.var()), m.mk_or(ctx.bool_var2expr(l2.var()), ctx.bool_var2expr(l3.var()))); @@ -914,7 +899,6 @@ namespace smt { */ bool theory_jobscheduler::split_job2resource(unsigned j) { job_info const& ji = m_jobs[j]; - context& ctx = get_context(); if (ji.m_is_bound) return false; auto const& jrs = ji.m_resources; for (job_resource const& jr : jrs) { diff --git a/src/smt/theory_jobscheduler.h b/src/smt/theory_jobscheduler.h index 55ece4da4..9c0e73b30 100644 --- a/src/smt/theory_jobscheduler.h +++ b/src/smt/theory_jobscheduler.h @@ -133,7 +133,7 @@ namespace smt { public: - theory_jobscheduler(ast_manager& m); + theory_jobscheduler(context& ctx); ~theory_jobscheduler() override {} diff --git a/src/smt/theory_lra.cpp b/src/smt/theory_lra.cpp index c0a993a5a..308a02750 100644 --- a/src/smt/theory_lra.cpp +++ b/src/smt/theory_lra.cpp @@ -170,7 +170,6 @@ class theory_lra::imp { theory_lra& th; ast_manager& m; - theory_arith_params& m_arith_params; arith_util a; arith_eq_adapter m_arith_eq_adapter; vector m_columns; @@ -362,6 +361,7 @@ class theory_lra::imp { context& ctx() const { return th.get_context(); } theory_id get_id() const { return th.get_id(); } + theory_arith_params const& params() const { return ctx().get_fparams(); } bool is_int(theory_var v) const { return is_int(get_enode(v)); } bool is_int(enode* n) const { return a.is_int(n->get_owner()); } bool is_real(theory_var v) const { return is_real(get_enode(v)); } @@ -373,42 +373,6 @@ class theory_lra::imp { lp::lar_solver& lp(){ return *m_solver.get(); } const lp::lar_solver& lp() const { return *m_solver.get(); } - void init_solver() { - if (m_solver) return; - - reset_variable_values(); - m_solver = alloc(lp::lar_solver); - - // initialize 0, 1 variables: - get_one(true); - get_one(false); - get_zero(true); - get_zero(false); - - smt_params_helper lpar(ctx().get_params()); - lp().settings().set_resource_limit(m_resource_limit); - lp().settings().simplex_strategy() = static_cast(lpar.arith_simplex_strategy()); - lp().settings().bound_propagation() = BP_NONE != propagation_mode(); - lp().settings().m_enable_hnf = lpar.arith_enable_hnf(); - lp().settings().m_print_external_var_name = lpar.arith_print_ext_var_names(); - lp().set_track_pivoted_rows(lpar.arith_bprop_on_pivoted_rows()); - lp().settings().report_frequency = lpar.arith_rep_freq(); - lp().settings().print_statistics = lpar.arith_print_stats(); - - // todo : do not use m_arith_branch_cut_ratio for deciding on cheap cuts - unsigned branch_cut_ratio = ctx().get_fparams().m_arith_branch_cut_ratio; - lp().set_cut_strategy(branch_cut_ratio); - - lp().settings().m_int_run_gcd_test = ctx().get_fparams().m_arith_gcd_test; - lp().settings().set_random_seed(ctx().get_fparams().m_random_seed); - m_switcher.m_use_nla = true; - m_lia = alloc(lp::int_solver, *m_solver.get()); - get_one(true); - get_zero(true); - get_one(false); - get_zero(false); - } - void ensure_nra() { if (!m_nra) { m_nra = alloc(nra::solver, *m_solver.get(), m.limit(), ctx().get_params()); @@ -753,7 +717,7 @@ class theory_lra::imp { } bool reflect(app* n) const { - return m_arith_params.m_arith_reflect || is_underspecified(n); + return params().m_arith_reflect || is_underspecified(n); } bool has_var(expr* n) { @@ -995,11 +959,10 @@ class theory_lra::imp { public: - imp(theory_lra& th, ast_manager& m, theory_arith_params& ap): + imp(theory_lra& th, ast_manager& m): th(th), m(m), - m_arith_params(ap), a(m), - m_arith_eq_adapter(th, ap, a), + m_arith_eq_adapter(th, a), m_internalize_head(0), m_one_var(UINT_MAX), m_zero_var(UINT_MAX), @@ -1022,8 +985,40 @@ public: std::for_each(m_internalize_states.begin(), m_internalize_states.end(), delete_proc()); } - void init(context* ctx) { - init_solver(); + void init() { + if (m_solver) return; + + reset_variable_values(); + m_solver = alloc(lp::lar_solver); + + // initialize 0, 1 variables: + get_one(true); + get_one(false); + get_zero(true); + get_zero(false); + + smt_params_helper lpar(ctx().get_params()); + lp().settings().set_resource_limit(m_resource_limit); + lp().settings().simplex_strategy() = static_cast(lpar.arith_simplex_strategy()); + lp().settings().bound_propagation() = BP_NONE != propagation_mode(); + lp().settings().m_enable_hnf = lpar.arith_enable_hnf(); + lp().settings().m_print_external_var_name = lpar.arith_print_ext_var_names(); + lp().set_track_pivoted_rows(lpar.arith_bprop_on_pivoted_rows()); + lp().settings().report_frequency = lpar.arith_rep_freq(); + lp().settings().print_statistics = lpar.arith_print_stats(); + + // todo : do not use m_arith_branch_cut_ratio for deciding on cheap cuts + unsigned branch_cut_ratio = ctx().get_fparams().m_arith_branch_cut_ratio; + lp().set_cut_strategy(branch_cut_ratio); + + lp().settings().m_int_run_gcd_test = ctx().get_fparams().m_arith_gcd_test; + lp().settings().set_random_seed(ctx().get_fparams().m_random_seed); + m_switcher.m_use_nla = true; + m_lia = alloc(lp::int_solver, *m_solver.get()); + get_one(true); + get_zero(true); + get_one(false); + get_zero(false); } void internalize_is_int(app * n) { @@ -1433,7 +1428,7 @@ public: }; if_trace_stream _ts(m, log); } - if (m_arith_params.m_arith_enum_const_mod && k.is_pos() && k < rational(8)) { + if (params().m_arith_enum_const_mod && k.is_pos() && k < rational(8)) { unsigned _k = k.get_unsigned(); literal_buffer lits; expr_ref_vector exprs(m); @@ -3064,13 +3059,13 @@ public: } - bool dump_lemmas() const { return m_arith_params.m_arith_dump_lemmas; } + bool dump_lemmas() const { return params().m_arith_dump_lemmas; } - bool propagate_eqs() const { return m_arith_params.m_arith_propagate_eqs && m_num_conflicts < m_arith_params.m_arith_propagation_threshold; } + bool propagate_eqs() const { return params().m_arith_propagate_eqs && m_num_conflicts < params().m_arith_propagation_threshold; } - bound_prop_mode propagation_mode() const { return m_num_conflicts < m_arith_params.m_arith_propagation_threshold ? m_arith_params.m_arith_bound_prop : BP_NONE; } + bound_prop_mode propagation_mode() const { return m_num_conflicts < params().m_arith_propagation_threshold ? params().m_arith_bound_prop : BP_NONE; } - unsigned small_lemma_size() const { return m_arith_params.m_arith_small_lemma_size; } + unsigned small_lemma_size() const { return params().m_arith_small_lemma_size; } bool proofs_enabled() const { return m.proofs_enabled(); } @@ -3544,7 +3539,7 @@ public: } bool validate_conflict(literal_vector const& core, svector const& eqs) { - if (m_arith_params.m_arith_mode != AS_NEW_ARITH) return true; + if (params().m_arith_mode != AS_NEW_ARITH) return true; scoped_arith_mode _sa(ctx().get_fparams()); context nctx(m, ctx().get_fparams(), ctx().get_params()); add_background(nctx); @@ -3563,7 +3558,7 @@ public: } bool validate_assign(literal lit, literal_vector const& core, svector const& eqs) { - if (m_arith_params.m_arith_mode != AS_NEW_ARITH) return true; + if (params().m_arith_mode != AS_NEW_ARITH) return true; scoped_arith_mode _sa(ctx().get_fparams()); context nctx(m, ctx().get_fparams(), ctx().get_params()); m_core.push_back(~lit); @@ -3578,7 +3573,7 @@ public: } bool validate_eq(enode* x, enode* y) { - if (m_arith_params.m_arith_mode == AS_NEW_ARITH) return true; + if (params().m_arith_mode == AS_NEW_ARITH) return true; context nctx(m, ctx().get_fparams(), ctx().get_params()); add_background(nctx); nctx.assert_expr(m.mk_not(m.mk_eq(x->get_owner(), y->get_owner()))); @@ -3913,20 +3908,20 @@ public: } }; -theory_lra::theory_lra(ast_manager& m, theory_arith_params& ap): - theory(m.get_family_id("arith")) { - m_imp = alloc(imp, *this, m, ap); +theory_lra::theory_lra(context& ctx): + theory(ctx, ctx.get_manager().get_family_id("arith")) { + m_imp = alloc(imp, *this, ctx.get_manager()); } theory_lra::~theory_lra() { dealloc(m_imp); } theory* theory_lra::mk_fresh(context* new_ctx) { - return alloc(theory_lra, new_ctx->get_manager(), new_ctx->get_fparams()); + return alloc(theory_lra, *new_ctx); } -void theory_lra::init(context * ctx) { - theory::init(ctx); - m_imp->init(ctx); +void theory_lra::init() { + m_imp->init(); } + bool theory_lra::internalize_atom(app * atom, bool gate_ctx) { return m_imp->internalize_atom(atom, gate_ctx); } diff --git a/src/smt/theory_lra.h b/src/smt/theory_lra.h index 9611e9ce6..c6e8dbfe7 100644 --- a/src/smt/theory_lra.h +++ b/src/smt/theory_lra.h @@ -28,13 +28,13 @@ namespace smt { imp* m_imp; public: - theory_lra(ast_manager& m, theory_arith_params& ap); + theory_lra(context& ctx); ~theory_lra() override; theory* mk_fresh(context* new_ctx) override; char const* get_name() const override { return "arithmetic"; } - - void init(context * ctx) override; + void init() override; + bool internalize_atom(app * atom, bool gate_ctx) override; bool internalize_term(app * term) override; diff --git a/src/smt/theory_pb.cpp b/src/smt/theory_pb.cpp index 11c83a9d4..00b0e24fe 100644 --- a/src/smt/theory_pb.cpp +++ b/src/smt/theory_pb.cpp @@ -433,17 +433,17 @@ namespace smt { // ------------------------ // theory_pb - theory_pb::theory_pb(ast_manager& m, theory_pb_params& p): - theory(m.mk_family_id("pb")), - m_params(p), - pb(m), + theory_pb::theory_pb(context& ctx): + theory(ctx, ctx.get_manager().mk_family_id("pb")), + m_params(ctx.get_fparams()), + pb(ctx.get_manager()), m_restart_lim(3), m_restart_inc(0), - m_antecedent_exprs(m), - m_cardinality_exprs(m) + m_antecedent_exprs(ctx.get_manager()), + m_cardinality_exprs(ctx.get_manager()) { - m_learn_complements = p.m_pb_learn_complements; - m_conflict_frequency = p.m_pb_conflict_frequency; + m_learn_complements = ctx.get_fparams().m_pb_learn_complements; + m_conflict_frequency = ctx.get_fparams().m_pb_conflict_frequency; } theory_pb::~theory_pb() { @@ -451,12 +451,10 @@ namespace smt { } theory * theory_pb::mk_fresh(context * new_ctx) { - return alloc(theory_pb, new_ctx->get_manager(), new_ctx->get_fparams()); + return alloc(theory_pb, *new_ctx); } bool theory_pb::internalize_atom(app * atom, bool gate_ctx) { - context& ctx = get_context(); - ast_manager& m = get_manager(); if (ctx.b_internalized(atom)) { return true; @@ -593,8 +591,6 @@ namespace smt { } literal theory_pb::compile_arg(expr* arg) { - context& ctx = get_context(); - ast_manager& m = get_manager(); bool_var bv; bool has_bv = false; @@ -784,7 +780,6 @@ namespace smt { } bool theory_pb::internalize_card(app * atom, bool gate_ctx) { - context& ctx = get_context(); if (ctx.b_internalized(atom)) { return true; } @@ -841,7 +836,6 @@ namespace smt { // \brief define cardinality constraint as conjunction. // void theory_pb::card2conjunction(card const& c) { - context& ctx = get_context(); literal lit = c.lit(); literal_vector& lits = get_literals(); for (unsigned i = 0; i < c.size(); ++i) { @@ -856,7 +850,6 @@ namespace smt { } void theory_pb::card2disjunction(card const& c) { - context& ctx = get_context(); literal lit = c.lit(); literal_vector& lits = get_literals(); for (unsigned i = 0; i < c.size(); ++i) { @@ -902,7 +895,6 @@ namespace smt { } std::ostream& theory_pb::display(std::ostream& out, card const& c, bool values) const { - context& ctx = get_context(); out << c.lit(); if (c.lit() != null_literal) { if (values) { @@ -936,7 +928,6 @@ namespace smt { void theory_pb::add_clause(card& c, literal_vector const& lits) { m_stats.m_num_conflicts++; - context& ctx = get_context(); justification* js = nullptr; c.inc_propagations(*this); if (!resolve_conflict(c, lits)) { @@ -949,7 +940,6 @@ namespace smt { } void theory_pb::add_assign(card& c, literal l) { - context& ctx = get_context(); if (ctx.get_assignment(l) == l_true) { return; } @@ -1001,7 +991,6 @@ namespace smt { void theory_pb::assign_eh(bool_var v, bool is_true) { ptr_vector* ineqs = nullptr; - context& ctx = get_context(); literal nlit(v, is_true); init_watch(v); TRACE("pb", tout << "assign: " << ~nlit << "\n";); @@ -1057,7 +1046,6 @@ namespace smt { } literal_vector& theory_pb::get_all_literals(ineq& c, bool negate) { - context& ctx = get_context(); literal_vector& lits = get_literals(); for (unsigned i = 0; i < c.size(); ++i) { literal l = c.lit(i); @@ -1078,7 +1066,6 @@ namespace smt { literal_vector& theory_pb::get_helpful_literals(ineq& c, bool negate) { scoped_mpz sum(m_mpz_mgr); mpz const& k = c.mpz_k(); - context& ctx = get_context(); literal_vector& lits = get_literals(); for (unsigned i = 0; sum < k && i < c.size(); ++i) { literal l = c.lit(i); @@ -1093,7 +1080,6 @@ namespace smt { } literal_vector& theory_pb::get_unhelpful_literals(ineq& c, bool negate) { - context& ctx = get_context(); literal_vector& lits = get_literals(); for (unsigned i = 0; i < c.size(); ++i) { literal l = c.lit(i); @@ -1121,7 +1107,6 @@ namespace smt { and/or relatively few compared to number of argumets. */ void theory_pb::assign_ineq(ineq& c, bool is_true) { - context& ctx = get_context(); ctx.push_trail(value_trail(c.m_max_sum)); ctx.push_trail(value_trail(c.m_min_sum)); ctx.push_trail(value_trail(c.m_nfixed)); @@ -1192,7 +1177,6 @@ namespace smt { */ bool theory_pb::assign_watch_ge(bool_var v, bool is_true, ineq_watch& watch, unsigned watch_index) { bool removed = false; - context& ctx = get_context(); ineq& c = *watch[watch_index]; unsigned w = c.find_lit(v, 0, c.watch_size()); SASSERT(ctx.get_assignment(c.lit()) == l_true); @@ -1326,7 +1310,7 @@ namespace smt { // for testing literal theory_pb::assert_ge(context& ctx, unsigned k, unsigned n, literal const* xs) { theory_pb_params p; - theory_pb th(ctx.get_manager(), p); + theory_pb th(ctx); psort_expr ps(ctx, th); psort_nw sort(ps); return sort.ge(false, k, n, xs); @@ -1342,7 +1326,6 @@ namespace smt { bool theory_pb::gc() { - context& ctx = get_context(); unsigned z = 0, nz = 0; m_occs.reset(); @@ -1469,7 +1452,6 @@ namespace smt { void theory_pb::init_watch_literal(ineq& c) { - context& ctx = get_context(); scoped_mpz max_k(m_mpz_mgr); c.m_watch_sum.reset(); c.m_watch_sz = 0; @@ -1512,7 +1494,6 @@ namespace smt { void theory_pb::add_assign(ineq& c, literal_vector const& lits, literal l) { inc_propagations(c); m_stats.m_num_propagations++; - context& ctx = get_context(); TRACE("pb", tout << "#prop:" << c.m_num_propagations << " - " << lits; tout << " => " << l << "\n"; display(tout, c, true);); @@ -1528,7 +1509,6 @@ namespace smt { void theory_pb::add_clause(ineq& c, literal_vector const& lits) { inc_propagations(c); m_stats.m_num_conflicts++; - context& ctx = get_context(); TRACE("pb", tout << "#prop:" << c.m_num_propagations << " - " << lits << "\n"; display(tout, c, true);); justification* js = nullptr; @@ -1557,7 +1537,6 @@ namespace smt { } void theory_pb::process_antecedent(literal l, int offset) { - context& ctx = get_context(); SASSERT(ctx.get_assignment(l) == l_false); bool_var v = l.var(); unsigned lvl = ctx.get_assign_level(v); @@ -1570,7 +1549,6 @@ namespace smt { } void theory_pb::process_card(card& c, int offset) { - context& ctx = get_context(); SASSERT(c.k() <= c.size()); SASSERT(ctx.get_assignment(c.lit()) == l_true); for (unsigned i = c.k(); i < c.size(); ++i) { @@ -1586,7 +1564,6 @@ namespace smt { bool theory_pb::validate_lemma() { int value = -m_bound; - context& ctx = get_context(); normalize_active_coeffs(); for (unsigned i = 0; i < m_active_vars.size(); ++i) { bool_var v = m_active_vars[i]; @@ -1610,7 +1587,6 @@ namespace smt { static bool validating = true; // false; if (validating) return true; validating = true; - ast_manager& m = get_manager(); smt_params fp; kernel k(m, fp); expr_ref notB(m.mk_not(B), m); @@ -1628,7 +1604,6 @@ namespace smt { } app_ref theory_pb::justification2expr(b_justification& js, literal conseq) { - ast_manager& m = get_manager(); app_ref result(m.mk_true(), m); expr_ref_vector args(m); vector coeffs; @@ -1692,7 +1667,6 @@ namespace smt { Note that an asserting literal should be false with respect to the resolvent inequality. */ literal theory_pb::get_asserting_literal(literal p) { - context& ctx = get_context(); unsigned lvl = 0; TRACE("pb", tout << p << " " << ctx.get_assignment(p) << "\n";); @@ -1831,8 +1805,6 @@ namespace smt { TRACE("pb", display(tout, c, true); ); bool_var v; - context& ctx = get_context(); - ast_manager& m = get_manager(); m_conflict_lvl = 0; for (literal lit : confl) { SASSERT(ctx.get_assignment(lit) == l_false); @@ -2044,14 +2016,14 @@ namespace smt { } bool theory_pb::is_proof_justification(justification const& j) const { - return typeid(smt::justification_proof_wrapper) == typeid(j) || get_manager().proofs_enabled(); + return typeid(smt::justification_proof_wrapper) == typeid(j) || m.proofs_enabled(); } justification* theory_pb::justify(literal l1, literal l2) { literal lits[2] = { l1, l2 }; justification* js = nullptr; if (proofs_enabled()) { - js = get_context().mk_justification(theory_axiom_justification(get_id(), get_context().get_region(), 2, lits)); + js = ctx.mk_justification(theory_axiom_justification(get_id(), ctx.get_region(), 2, lits)); } return js; } @@ -2059,7 +2031,7 @@ namespace smt { justification* theory_pb::justify(literal_vector const& lits) { justification* js = nullptr; if (proofs_enabled()) { - js = get_context().mk_justification(theory_axiom_justification(get_id(), get_context().get_region(), lits.size(), lits.c_ptr())); + js = ctx.mk_justification(theory_axiom_justification(get_id(), ctx.get_region(), lits.size(), lits.c_ptr())); } return js; } @@ -2082,11 +2054,11 @@ namespace smt { void theory_pb::validate_assign(ineq const& c, literal_vector const& lits, literal l) const { uint_set nlits; for (literal lit : lits) { - SASSERT(get_context().get_assignment(lit) == l_true); + SASSERT(ctx.get_assignment(lit) == l_true); nlits.insert((~lit).index()); } - SASSERT(get_context().get_assignment(l) == l_undef); - SASSERT(get_context().get_assignment(c.lit()) == l_true); + SASSERT(ctx.get_assignment(l) == l_undef); + SASSERT(ctx.get_assignment(c.lit()) == l_true); nlits.insert(l.index()); numeral sum = numeral::zero(); for (unsigned i = 0; i < c.size(); ++i) { @@ -2115,7 +2087,6 @@ namespace smt { } void theory_pb::validate_final_check(card& c) { - context& ctx = get_context(); if (ctx.get_assignment(c.lit()) == l_undef) { TRACE("pb", display(tout << "is undef ", c, true);); return; @@ -2147,7 +2118,6 @@ namespace smt { } void theory_pb::validate_final_check(ineq& c) { - context& ctx = get_context(); if (ctx.get_assignment(c.lit()) == l_undef) { TRACE("pb", tout << c.lit() << " is undef\n";); @@ -2182,7 +2152,6 @@ namespace smt { } bool theory_pb::validate_antecedents(literal_vector const& lits) { - context& ctx = get_context(); for (literal lit : lits) { if (ctx.get_assignment(lit) != l_true) { return false; @@ -2192,7 +2161,6 @@ namespace smt { } bool theory_pb::validate_unit_propagation(card const& c) { - context& ctx = get_context(); for (unsigned i = c.k(); i < c.size(); ++i) { if (ctx.get_assignment(c.lit(i)) != l_false) { return false; @@ -2202,13 +2170,11 @@ namespace smt { } app_ref theory_pb::literal2expr(literal lit) { - ast_manager& m = get_manager(); app_ref arg(m.mk_const(symbol((unsigned)lit.var()), m.mk_bool_sort()), m); return app_ref(lit.sign() ? m.mk_not(arg) : arg, m); } app_ref theory_pb::active2expr() { - ast_manager& m = get_manager(); expr_ref_vector args(m); vector coeffs; normalize_active_coeffs(); @@ -2225,7 +2191,6 @@ namespace smt { // display methods void theory_pb::display_resolved_lemma(std::ostream& out) const { - context& ctx = get_context(); out << "num marks: " << m_num_marks << "\n"; out << "conflict level: " << m_conflict_lvl << "\n"; for (literal r : m_resolved) { @@ -2264,12 +2229,10 @@ namespace smt { } std::ostream& theory_pb::display(std::ostream& out, arg_t const& c, bool values) const { - return c.display(get_context(), out, values); + return c.display(ctx, out, values); } std::ostream& theory_pb::display(std::ostream& out, ineq const& c, bool values) const { - ast_manager& m = get_manager(); - context& ctx = get_context(); out << c.lit(); if (c.lit() != null_literal) { if (values) { @@ -2389,7 +2352,6 @@ namespace smt { } model_value_proc * theory_pb::mk_value(enode * n, model_generator & mg) { - context& ctx = get_context(); app* a = n->get_owner(); pb_model_value_proc* p = alloc(pb_model_value_proc, a); for (unsigned i = 0; i < a->get_num_args(); ++i) { diff --git a/src/smt/theory_pb.h b/src/smt/theory_pb.h index 7908ca879..150b72744 100644 --- a/src/smt/theory_pb.h +++ b/src/smt/theory_pb.h @@ -404,7 +404,7 @@ namespace smt { justification* justify(literal_vector const& lits); public: - theory_pb(ast_manager& m, theory_pb_params& p); + theory_pb(context& ctx); ~theory_pb() override; diff --git a/src/smt/theory_recfun.cpp b/src/smt/theory_recfun.cpp index 4fa0db63e..4c1de1f71 100644 --- a/src/smt/theory_recfun.cpp +++ b/src/smt/theory_recfun.cpp @@ -27,9 +27,8 @@ Revision History: namespace smt { - theory_recfun::theory_recfun(ast_manager & m) - : theory(m.mk_family_id("recfun")), - m(m), + theory_recfun::theory_recfun(context& ctx) + : theory(ctx, ctx.get_manager().mk_family_id("recfun")), m_plugin(*reinterpret_cast(m.get_plugin(get_family_id()))), m_util(m_plugin.u()), m_disabled_guards(m), @@ -38,6 +37,7 @@ namespace smt { m_num_rounds(0), m_q_case_expand(), m_q_body_expand() { + m_num_rounds = 0; } theory_recfun::~theory_recfun() { @@ -47,12 +47,7 @@ namespace smt { char const * theory_recfun::get_name() const { return "recfun"; } theory* theory_recfun::mk_fresh(context* new_ctx) { - return alloc(theory_recfun, new_ctx->get_manager()); - } - - void theory_recfun::init(context* ctx) { - theory::init(ctx); - m_num_rounds = 0; + return alloc(theory_recfun, *new_ctx); } void theory_recfun::init_search_eh() { @@ -64,16 +59,16 @@ namespace smt { return false; } for (expr * arg : *atom) { - ctx().internalize(arg, false); + ctx.internalize(arg, false); } - if (!ctx().e_internalized(atom)) { - ctx().mk_enode(atom, false, true, false); + if (!ctx.e_internalized(atom)) { + ctx.mk_enode(atom, false, true, false); } - if (!ctx().b_internalized(atom)) { - bool_var v = ctx().mk_bool_var(atom); - ctx().set_var_theory(v, get_id()); + if (!ctx.b_internalized(atom)) { + bool_var v = ctx.mk_bool_var(atom); + ctx.set_var_theory(v, get_id()); } - if (!ctx().relevancy() && u().is_defined(atom)) { + if (!ctx.relevancy() && u().is_defined(atom)) { push_case_expand(alloc(case_expansion, u(), atom)); } return true; @@ -84,12 +79,12 @@ namespace smt { return false; } for (expr* e : *term) { - ctx().internalize(e, false); + ctx.internalize(e, false); } // the internalization of the arguments may have triggered the internalization of term. - if (!ctx().e_internalized(term)) { - ctx().mk_enode(term, false, false, true); - if (!ctx().relevancy() && u().is_defined(term)) { + if (!ctx.e_internalized(term)) { + ctx.mk_enode(term, false, false, true); + if (!ctx.relevancy() && u().is_defined(term)) { push_case_expand(alloc(case_expansion, u(), term)); } } @@ -128,7 +123,7 @@ namespace smt { * body-expand it. */ void theory_recfun::relevant_eh(app * n) { - SASSERT(ctx().relevancy()); + SASSERT(ctx.relevancy()); TRACEFN("relevant_eh: (defined) " << u().is_defined(n) << " " << mk_pp(n, m)); if (u().is_defined(n) && u().has_defs()) { push_case_expand(alloc(case_expansion, u(), n)); @@ -182,8 +177,8 @@ namespace smt { m_q_guards.reset(); for (literal_vector & c : m_q_clauses) { - TRACEFN("add axiom " << pp_lits(ctx(), c)); - ctx().mk_th_axiom(get_id(), c); + TRACEFN("add axiom " << pp_lits(ctx, c)); + ctx.mk_th_axiom(get_id(), c); } m_q_clauses.clear(); @@ -229,7 +224,7 @@ namespace smt { m_disabled_guards.push_back(nguard); SASSERT(!m_guard2pending.contains(nguard)); m_guard2pending.insert(nguard, alloc(expr_ref_vector, guards)); - TRACEFN("add clause\n" << pp_lits(ctx(), c)); + TRACEFN("add clause\n" << pp_lits(ctx, c)); m_q_clauses.push_back(std::move(c)); } @@ -271,7 +266,7 @@ namespace smt { * then body-expand i-th case of `f(t1...tn)` */ void theory_recfun::assign_eh(bool_var v, bool is_true) { - expr* e = ctx().bool_var2expr(v); + expr* e = ctx.bool_var2expr(v); if (is_true && u().is_case_pred(e)) { TRACEFN("assign_case_pred_true " << mk_pp(e, m)); // body-expand @@ -289,15 +284,15 @@ namespace smt { var_subst subst(m, true); expr_ref new_body(m); new_body = subst(e, args.size(), args.c_ptr()); - ctx().get_rewriter()(new_body); // simplify + ctx.get_rewriter()(new_body); // simplify set_depth_rec(depth + 1, new_body); return new_body; } literal theory_recfun::mk_literal(expr* e) { - ctx().internalize(e, false); - literal lit = ctx().get_literal(e); - ctx().mark_as_relevant(lit); + ctx.internalize(e, false); + literal lit = ctx.get_literal(e); + ctx.mark_as_relevant(lit); return lit; } @@ -315,7 +310,7 @@ namespace smt { else { lit = mk_eq(l, r, false); } - ctx().mark_as_relevant(lit); + ctx.mark_as_relevant(lit); return lit; } @@ -336,8 +331,8 @@ namespace smt { literal lit = mk_eq_lit(lhs, rhs); std::function fn = [&]() { return lit; }; scoped_trace_stream _tr(*this, fn); - ctx().mk_th_axiom(get_id(), 1, &lit); - TRACEFN("macro expansion yields " << pp_lit(ctx(), lit)); + ctx.mk_th_axiom(get_id(), 1, &lit); + TRACEFN("macro expansion yields " << pp_lit(ctx, lit)); } /** @@ -385,15 +380,15 @@ namespace smt { // to close the available cases. { scoped_trace_stream _tr2(*this, preds); - ctx().mk_th_axiom(get_id(), preds); + ctx.mk_th_axiom(get_id(), preds); } (void)max_depth; // add_induction_lemmas(max_depth); } void theory_recfun::add_induction_lemmas(unsigned depth) { - if (depth > 4 && ctx().get_fparams().m_induction && induction::should_try(ctx())) { - ctx().get_induction()(); + if (depth > 4 && ctx.get_fparams().m_induction && induction::should_try(ctx)) { + ctx.get_induction()(); } } @@ -407,11 +402,11 @@ namespace smt { literal c[2] = {~concl, guard}; std::function fn = [&]() { return literal_vector(2, c); }; scoped_trace_stream _tr(*this, fn); - ctx().mk_th_axiom(get_id(), 2, c); + ctx.mk_th_axiom(get_id(), 2, c); } std::function fn1 = [&]() { return lguards; }; scoped_trace_stream _tr1(*this, fn1); - ctx().mk_th_axiom(get_id(), lguards); + ctx.mk_th_axiom(get_id(), lguards); } /** @@ -445,9 +440,9 @@ namespace smt { clause.push_back(mk_eq_lit(lhs, rhs)); std::function fn = [&]() { return clause; }; scoped_trace_stream _tr(*this, fn); - ctx().mk_th_axiom(get_id(), clause); + ctx.mk_th_axiom(get_id(), clause); TRACEFN("body " << pp_body_expansion(e,m)); - TRACEFN(pp_lits(ctx(), clause)); + TRACEFN(pp_lits(ctx, clause)); } final_check_status theory_recfun::final_check_eh() { @@ -482,7 +477,7 @@ namespace smt { unsigned depth = get_depth(ne); if (depth < current_depth) n = 0; - if (depth <= current_depth && (get_context().get_random_value() % (++n)) == 0) { + if (depth <= current_depth && (ctx.get_random_value() % (++n)) == 0) { to_delete = e; current_depth = depth; } diff --git a/src/smt/theory_recfun.h b/src/smt/theory_recfun.h index 67e475aae..db9d28e9c 100644 --- a/src/smt/theory_recfun.h +++ b/src/smt/theory_recfun.h @@ -89,7 +89,6 @@ namespace smt { friend std::ostream& operator<<(std::ostream&, pp_body_expansion const &); - ast_manager& m; recfun::decl::plugin& m_plugin; recfun::util& m_util; stats m_stats; @@ -158,10 +157,9 @@ namespace smt { void new_eq_eh(theory_var v1, theory_var v2) override {} void new_diseq_eh(theory_var v1, theory_var v2) override {} void add_theory_assumptions(expr_ref_vector & assumptions) override; - void init(context* ctx) override; public: - theory_recfun(ast_manager & m); + theory_recfun(context& ctx); ~theory_recfun() override; theory * mk_fresh(context * new_ctx) override; void init_search_eh() override; diff --git a/src/smt/theory_seq.cpp b/src/smt/theory_seq.cpp index bd1514c91..6b03a0c4d 100644 --- a/src/smt/theory_seq.cpp +++ b/src/smt/theory_seq.cpp @@ -274,10 +274,8 @@ void theory_seq::exclusion_table::display(std::ostream& out) const { } -theory_seq::theory_seq(ast_manager& m, theory_seq_params const & params): - theory(m.mk_family_id("seq")), - m(m), - m_params(params), +theory_seq::theory_seq(context& ctx): + theory(ctx, ctx.get_manager().mk_family_id("seq")), m_rep(m, m_dm), m_lts_checked(false), m_eq_id(0), @@ -313,6 +311,13 @@ theory_seq::theory_seq(ast_manager& m, theory_seq_params const & params): m_new_propagation(false), m_mk_aut(m) { +} + +theory_seq::~theory_seq() { + m_trail_stack.reset(); +} + +void theory_seq::init() { params_ref p; p.set_bool("coalesce_chars", false); m_rewrite.updt_params(p); @@ -323,16 +328,7 @@ theory_seq::theory_seq(ast_manager& m, theory_seq_params const & params): std::function mk_eq_emp = [&](expr* e, bool p) { return mk_eq_empty(e, p); }; m_ax.add_axiom5 = add_ax; m_ax.mk_eq_empty2 = mk_eq_emp; - -} - -theory_seq::~theory_seq() { - m_trail_stack.reset(); -} - -void theory_seq::init(context* ctx) { - theory::init(ctx); - m_arith_value.init(ctx); + m_arith_value.init(&ctx); } #define TRACEFIN(s) { TRACE("seq", tout << ">>" << s << "\n";); IF_VERBOSE(31, verbose_stream() << s << "\n"); } @@ -351,8 +347,8 @@ final_check_status theory_seq::final_check_eh() { return FC_DONE; } m_new_propagation = false; - TRACE("seq", display(tout << "level: " << get_context().get_scope_level() << "\n");); - TRACE("seq_verbose", get_context().display(tout);); + TRACE("seq", display(tout << "level: " << ctx.get_scope_level() << "\n");); + TRACE("seq_verbose", ctx.display(tout);); if (simplify_and_solve_eqs()) { ++m_stats.m_solve_eqs; @@ -378,7 +374,7 @@ final_check_status theory_seq::final_check_eh() { TRACEFIN("zero_length"); return FC_CONTINUE; } - if (m_params.m_split_w_len && len_based_split()) { + if (get_fparams().m_split_w_len && len_based_split()) { ++m_stats.m_branch_variable; TRACEFIN("split_based_on_length"); return FC_CONTINUE; @@ -499,7 +495,6 @@ bool theory_seq::fixed_length(expr* len_e, bool is_zero) { } - context& ctx = get_context(); m_trail_stack.push(insert_obj_trail(m_fixed, e)); m_fixed.insert(e); @@ -535,13 +530,12 @@ bool theory_seq::fixed_length(expr* len_e, bool is_zero) { lit => s != "" */ void theory_seq::propagate_non_empty(literal lit, expr* s) { - SASSERT(get_context().get_assignment(lit) == l_true); + SASSERT(ctx.get_assignment(lit) == l_true); propagate_lit(nullptr, 1, &lit, ~mk_eq_empty(s)); } bool theory_seq::propagate_is_conc(expr* e, expr* conc) { TRACE("seq", tout << mk_pp(conc, m) << " is non-empty\n";); - context& ctx = get_context(); literal lit = ~mk_eq_empty(e); if (ctx.get_assignment(lit) == l_true) { propagate_lit(nullptr, 1, &lit, mk_eq(e, conc, false)); @@ -574,7 +568,6 @@ void theory_seq::mk_decompose(expr* e, expr_ref& head, expr_ref& tail) { \brief Check extensionality (for sequences). */ bool theory_seq::check_extensionality() { - context& ctx = get_context(); unsigned sz = get_num_vars(); unsigned_vector seqs; for (unsigned v = 0; v < sz; ++v) { @@ -633,7 +626,6 @@ bool theory_seq::check_extensionality() { \brief check negated contains constraints. */ bool theory_seq::check_contains() { - context & ctx = get_context(); for (unsigned i = 0; !ctx.inconsistent() && i < m_ncs.size(); ++i) { if (solve_nc(i)) { m_ncs.erase_and_swap(i--); @@ -643,7 +635,6 @@ bool theory_seq::check_contains() { } bool theory_seq::check_lts() { - context& ctx = get_context(); if (m_lts.empty() || m_lts_checked) { return false; } @@ -719,7 +710,6 @@ bool theory_seq::is_solved() { #if 0 // debug code - context& ctx = get_context(); for (enode* n : ctx.enodes()) { expr* e = nullptr; rational len1, len2; @@ -744,8 +734,6 @@ bool theory_seq::is_solved() { \brief while extracting dependency literals ensure that they have all been asserted on the context. */ void theory_seq::linearize(dependency* dep, enode_pair_vector& eqs, literal_vector& lits) const { - context & ctx = get_context(); - (void)ctx; DEBUG_CODE(for (literal lit : lits) SASSERT(ctx.get_assignment(lit) == l_true); ); svector assumptions; const_cast(m_dm).linearize(dep, assumptions); @@ -765,7 +753,6 @@ void theory_seq::linearize(dependency* dep, enode_pair_vector& eqs, literal_vect void theory_seq::propagate_lit(dependency* dep, unsigned n, literal const* _lits, literal lit) { if (lit == true_literal) return; - context& ctx = get_context(); literal_vector lits(n, _lits); if (lit == false_literal) { @@ -801,7 +788,6 @@ void theory_seq::set_conflict(dependency* dep, literal_vector const& _lits) { } void theory_seq::set_conflict(enode_pair_vector const& eqs, literal_vector const& lits) { - context& ctx = get_context(); TRACE("seq", display_deps(tout << "assert conflict:", lits, eqs);); ctx.set_conflict( ctx.mk_justification( @@ -814,7 +800,6 @@ bool theory_seq::propagate_eq(dependency* dep, enode* n1, enode* n2) { if (n1->get_root() == n2->get_root()) { return false; } - context& ctx = get_context(); literal_vector lits; enode_pair_vector eqs; linearize(dep, eqs, lits); @@ -877,7 +862,6 @@ bool theory_seq::lift_ite(expr_ref_vector const& ls, expr_ref_vector const& rs, if (ls.size() != 1 || rs.size() != 1) { return false; } - context& ctx = get_context(); expr* c = nullptr, *t = nullptr, *e = nullptr; expr* l = ls[0], *r = rs[0]; if (m.is_ite(r)) { @@ -904,7 +888,6 @@ bool theory_seq::lift_ite(expr_ref_vector const& ls, expr_ref_vector const& rs, bool theory_seq::simplify_eq(expr_ref_vector& ls, expr_ref_vector& rs, dependency* deps) { - context& ctx = get_context(); expr_ref_pair_vector& new_eqs = m_new_eqs; new_eqs.reset(); bool changed = false; @@ -987,7 +970,7 @@ bool theory_seq::solve_itos(expr* n, expr_ref_vector const& rs, dependency* dep) m_is_digit.insert(u); m_trail_stack.push(insert_obj_trail(m_is_digit, u)); literal is_digit = m_ax.is_digit(u); - if (get_context().get_assignment(is_digit) != l_true) { + if (ctx.get_assignment(is_digit) != l_true) { propagate_lit(dep, 0, nullptr, is_digit); } } @@ -1155,7 +1138,6 @@ bool theory_seq::reduce_length_eq(expr_ref_vector const& ls, expr_ref_vector con } bool theory_seq::reduce_length(unsigned i, unsigned j, bool front, expr_ref_vector const& ls, expr_ref_vector const& rs, dependency* deps) { - context& ctx = get_context(); expr* const* ls1 = ls.c_ptr(); expr* const* ls2 = ls.c_ptr()+i; expr* const* rs1 = rs.c_ptr(); @@ -1204,13 +1186,11 @@ bool theory_seq::reduce_length(unsigned i, unsigned j, bool front, expr_ref_vect to another. */ bool theory_seq::is_safe_to_copy(bool_var v) const { - context & ctx = get_context(); expr* e = ctx.bool_var2expr(v); return !m_sk.is_skolem(e); } bool theory_seq::get_length(expr* e, expr_ref& len, literal_vector& lits) { - context& ctx = get_context(); expr* s, *i, *l; rational r; if (m_util.str.is_extract(e, s, i, l)) { @@ -1307,7 +1287,6 @@ bool theory_seq::get_length(expr* e, expr_ref& len, literal_vector& lits) { bool theory_seq::solve_nc(unsigned idx) { nc const& n = m_ncs[idx]; literal len_gt = n.len_gt(); - context& ctx = get_context(); expr_ref c(m); #if 1 expr* a = nullptr, *b = nullptr; @@ -1519,7 +1498,6 @@ bool theory_seq::explain_empty(expr_ref_vector& es, dependency*& dep) { } bool theory_seq::simplify_and_solve_eqs() { - context & ctx = get_context(); m_new_solution = true; while (m_new_solution && !ctx.inconsistent()) { m_new_solution = false; @@ -1537,7 +1515,6 @@ bool theory_seq::internalize_atom(app* a, bool) { bool theory_seq::internalize_term(app* term) { m_has_seq = true; - context & ctx = get_context(); if (ctx.e_internalized(term)) { enode* e = ctx.get_enode(term); mk_var(e); @@ -1638,7 +1615,7 @@ bool theory_seq::check_int_string() { bool theory_seq::check_int_string(expr* e) { expr* n = nullptr; - if (get_context().inconsistent()) + if (ctx.inconsistent()) return true; if (m_util.str.is_itos(e, n) && !m_util.str.is_stoi(n) && add_length_to_eqc(e)) return true; @@ -1781,13 +1758,12 @@ std::ostream& theory_seq::display_deps_smt2(std::ostream& out, literal_vector co << ")\n"; } for (literal l : lits) { - get_context().display_literal_smt2(out, l) << "\n"; + ctx.display_literal_smt2(out, l) << "\n"; } return out; } std::ostream& theory_seq::display_lit(std::ostream& out, literal l) const { - context& ctx = get_context(); if (l == true_literal) { out << " true"; } @@ -1833,7 +1809,7 @@ void theory_seq::init_search_eh() { m_re2aut.reset(); m_res.reset(); m_automata.reset(); - auto as = get_context().get_fparams().m_arith_mode; + auto as = get_fparams().m_arith_mode; if (m_has_seq && as != AS_OLD_ARITH && as != AS_NEW_ARITH) { throw default_exception("illegal arithmetic solver used with string solver"); } @@ -2001,7 +1977,6 @@ app* theory_seq::get_ite_value(expr* e) { model_value_proc * theory_seq::mk_value(enode * n, model_generator & mg) { app* e = n->get_owner(); - context& ctx = get_context(); TRACE("seq", tout << mk_pp(e, m) << "\n";); // Shortcut for well-founded values to avoid some quadratic overhead @@ -2136,7 +2111,6 @@ void theory_seq::validate_model(model& mdl) { #if 0 ptr_vector fmls; - context& ctx = get_context(); ctx.get_asserted_formulas(fmls); validate_model_proc proc(*this, mdl); for (expr* f : fmls) { @@ -2245,7 +2219,7 @@ expr_ref theory_seq::elim_skolem(expr* e) { } void theory_seq::validate_axiom(literal_vector const& lits) { - if (get_context().get_fparams().m_seq_validate) { + if (get_fparams().m_seq_validate) { enode_pair_vector eqs; literal_vector _lits; for (literal lit : lits) _lits.push_back(~lit); @@ -2256,7 +2230,7 @@ void theory_seq::validate_axiom(literal_vector const& lits) { void theory_seq::validate_conflict(enode_pair_vector const& eqs, literal_vector const& lits) { IF_VERBOSE(10, display_deps_smt2(verbose_stream() << "cn ", lits, eqs)); - if (get_context().get_fparams().m_seq_validate) { + if (get_fparams().m_seq_validate) { expr_ref_vector fmls(m); validate_fmls(eqs, lits, fmls); } @@ -2264,7 +2238,7 @@ void theory_seq::validate_conflict(enode_pair_vector const& eqs, literal_vector void theory_seq::validate_assign(literal lit, enode_pair_vector const& eqs, literal_vector const& lits) { IF_VERBOSE(10, display_deps_smt2(verbose_stream() << "eq ", lits, eqs); display_lit(verbose_stream(), ~lit) << "\n"); - if (get_context().get_fparams().m_seq_validate) { + if (get_fparams().m_seq_validate) { literal_vector _lits(lits); _lits.push_back(~lit); expr_ref_vector fmls(m); @@ -2276,7 +2250,7 @@ void theory_seq::validate_assign_eq(enode* a, enode* b, enode_pair_vector const& IF_VERBOSE(10, display_deps(verbose_stream() << "; assign-eq\n", lits, eqs); verbose_stream() << "(not (= " << mk_bounded_pp(a->get_owner(), m) << " " << mk_bounded_pp(b->get_owner(), m) << "))\n"); - if (get_context().get_fparams().m_seq_validate) { + if (get_fparams().m_seq_validate) { expr_ref_vector fmls(m); fmls.push_back(m.mk_not(m.mk_eq(a->get_owner(), b->get_owner()))); validate_fmls(eqs, lits, fmls); @@ -2284,7 +2258,6 @@ void theory_seq::validate_assign_eq(enode* a, enode* b, enode_pair_vector const& } void theory_seq::validate_fmls(enode_pair_vector const& eqs, literal_vector const& lits, expr_ref_vector& fmls) { - context& ctx = get_context(); smt_params fp; fp.m_seq_validate = false; expr_ref fml(m); @@ -2329,8 +2302,8 @@ theory_var theory_seq::mk_var(enode* n) { else { theory_var v = theory::mk_var(n); m_find.mk_var(); - get_context().attach_th_var(n, this, v); - get_context().mark_as_relevant(n); + ctx.attach_th_var(n, this, v); + ctx.mark_as_relevant(n); return v; } } @@ -2427,7 +2400,6 @@ bool theory_seq::expand1(expr* e0, dependency*& eqs, expr_ref& result) { expr* e1, *e2, *e3; expr_ref arg1(m), arg2(m); - context& ctx = get_context(); if (m_util.str.is_concat(e, e1, e2)) { arg1 = try_expand(e1, deps); arg2 = try_expand(e2, deps); @@ -2529,7 +2501,6 @@ void theory_seq::add_dependency(dependency*& dep, enode* a, enode* b) { void theory_seq::propagate() { - context & ctx = get_context(); while (m_axioms_head < m_axioms.size() && !ctx.inconsistent()) { expr_ref e(m); e = m_axioms[m_axioms_head].get(); @@ -2562,7 +2533,7 @@ void theory_seq::deque_axiom(expr* n) { TRACE("seq", tout << "deque: " << mk_bounded_pp(n, m, 2) << "\n";); if (m_util.str.is_length(n)) { m_ax.add_length_axiom(n); - if (!get_context().at_base_level()) { + if (!ctx.at_base_level()) { m_trail_stack.push(push_replay(alloc(replay_axiom, m, n))); } } @@ -2651,7 +2622,6 @@ void theory_seq::propagate_in_re(expr* n, bool is_true) { expr* s = nullptr, *_re = nullptr; VERIFY(m_util.str.is_in_re(n, s, _re)); expr_ref re(_re, m); - context& ctx = get_context(); literal lit = ctx.get_literal(n); if (!is_true) { re = m_util.re.mk_complement(re); @@ -2761,7 +2731,6 @@ bool theory_seq::upper_bound(expr* e, rational& hi) const { // the lower bound is not updated for all the enodes in the same eqc, // we have to traverse the eqc to query for the better lower bound. bool theory_seq::lower_bound2(expr* _e, rational& lo) { - context& ctx = get_context(); expr_ref e = mk_len(_e); expr_ref _lo(m); theory_mi_arith* tha = get_th_arith(ctx, m_autil.get_family_id(), e); @@ -2848,7 +2817,7 @@ bool theory_seq::get_length(expr* e, rational& val) { void theory_seq::ensure_nth(literal lit, expr* s, expr* idx) { TRACE("seq", tout << "ensure-nth: " << lit << " " << mk_bounded_pp(s, m, 2) << " " << mk_bounded_pp(idx, m, 2) << "\n";); rational r; - SASSERT(get_context().get_assignment(lit) == l_true); + SASSERT(ctx.get_assignment(lit) == l_true); VERIFY(m_autil.is_numeral(idx, r) && r.is_unsigned()); unsigned _idx = r.get_unsigned(); expr_ref head(m), tail(m), conc(m), len1(m), len2(m); @@ -2876,7 +2845,6 @@ literal theory_seq::mk_simplified_literal(expr * _e) { literal theory_seq::mk_literal(expr* _e) { expr_ref e(_e, m); - context& ctx = get_context(); ensure_enode(e); return ctx.get_literal(e); } @@ -2888,7 +2856,6 @@ literal theory_seq::mk_seq_eq(expr* a, expr* b) { literal theory_seq::mk_eq_empty(expr* _e, bool phase) { - context& ctx = get_context(); expr_ref e(_e, m); SASSERT(m_util.is_seq(e)); expr_ref emp(m); @@ -2915,7 +2882,6 @@ literal theory_seq::mk_eq_empty(expr* _e, bool phase) { } void theory_seq::add_axiom(literal l1, literal l2, literal l3, literal l4, literal l5) { - context& ctx = get_context(); literal_vector lits; if (l1 == true_literal || l2 == true_literal || l3 == true_literal || l4 == true_literal || l5 == true_literal) return; if (l1 != null_literal && l1 != false_literal) { ctx.mark_as_relevant(l1); lits.push_back(l1); } @@ -2955,7 +2921,6 @@ bool theory_seq::propagate_eq(literal lit, expr* e1, expr* e2, bool add_to_eqs) } bool theory_seq::propagate_eq(dependency* deps, literal_vector const& _lits, expr* e1, expr* e2, bool add_to_eqs) { - context& ctx = get_context(); enode* n1 = ensure_enode(e1); enode* n2 = ensure_enode(e2); @@ -2997,7 +2962,6 @@ bool theory_seq::propagate_eq(dependency* deps, literal_vector const& _lits, exp } void theory_seq::assign_eh(bool_var v, bool is_true) { - context & ctx = get_context(); expr* e = ctx.bool_var2expr(v); expr* e1 = nullptr, *e2 = nullptr; expr_ref f(m); @@ -3194,18 +3158,18 @@ void theory_seq::new_diseq_eh(theory_var v1, theory_var v2) { } m_exclude.update(e1, e2); expr_ref eq(m.mk_eq(e1, e2), m); - TRACE("seq", tout << "new disequality " << get_context().get_scope_level() << ": " << mk_bounded_pp(eq, m, 2) << "\n";); + TRACE("seq", tout << "new disequality " << ctx.get_scope_level() << ": " << mk_bounded_pp(eq, m, 2) << "\n";); m_rewrite(eq); if (!m.is_false(eq)) { literal lit = mk_eq(e1, e2, false); - get_context().mark_as_relevant(lit); + ctx.mark_as_relevant(lit); if (m_util.str.is_empty(e2)) { std::swap(e1, e2); } dependency* dep = m_dm.mk_leaf(assumption(~lit)); m_nqs.push_back(ne(e1, e2, dep)); - if (get_context().get_assignment(lit) != l_undef) { + if (ctx.get_assignment(lit) != l_undef) { solve_nqs(m_nqs.size() - 1); } } @@ -3225,7 +3189,6 @@ void theory_seq::push_scope_eh() { } void theory_seq::pop_scope_eh(unsigned num_scopes) { - context& ctx = get_context(); m_trail_stack.pop_scope(num_scopes); theory::pop_scope_eh(num_scopes); m_dm.pop_scope(num_scopes); @@ -3271,7 +3234,7 @@ void theory_seq::relevant_eh(app* n) { add_length_limit(arg, m_max_unfolding_depth, true); } - if (m_util.str.is_length(n, arg) && !has_length(arg) && get_context().e_internalized(arg)) { + if (m_util.str.is_length(n, arg) && !has_length(arg) && ctx.e_internalized(arg)) { add_length_to_eqc(arg); } } @@ -3283,7 +3246,7 @@ eautomaton* theory_seq::get_automaton(expr* re) { return result; } if (!m_mk_aut.has_solver()) { - m_mk_aut.set_solver(alloc(seq_expr_solver, m, get_context().get_fparams())); + m_mk_aut.set_solver(alloc(seq_expr_solver, m, ctx.get_fparams())); } result = m_mk_aut(re); CTRACE("seq", result, { display_expr d(m); result->display(tout, d); }); @@ -3320,7 +3283,7 @@ bool theory_seq::is_accept(expr* e, expr*& s, expr*& idx, expr*& re, unsigned& i step(s, idx, re, i, j, t) -> accept(s, idx + 1, re, j) */ void theory_seq::propagate_step(literal lit, expr* step) { - SASSERT(get_context().get_assignment(lit) == l_true); + SASSERT(ctx.get_assignment(lit) == l_true); expr* re = nullptr, *s = nullptr, *t = nullptr, *idx = nullptr, *i = nullptr, *j = nullptr; VERIFY(m_sk.is_step(step, s, idx, re, i, j, t)); @@ -3354,7 +3317,6 @@ void theory_seq::propagate_accept(literal lit, expr* acc) { ++m_stats.m_propagate_automata; expr *e = nullptr, *idx = nullptr, *re = nullptr; unsigned src = 0; - context& ctx = get_context(); rational _idx; eautomaton* aut = nullptr; if (!is_accept(acc, e, idx, re, src, aut)) @@ -3384,7 +3346,7 @@ void theory_seq::propagate_accept(literal lit, expr* acc) { for (auto const& mv : mvs) { expr_ref nth = mk_nth(e, idx); expr_ref t = mv.t()->accept(nth); - get_context().get_rewriter()(t); + ctx.get_rewriter()(t); expr_ref step_e(m_sk.mk_step(e, idx, re, src, mv.dst(), t), m); lits.push_back(mk_literal(step_e)); } @@ -3435,7 +3397,7 @@ bool theory_seq::should_research(expr_ref_vector & unsat_core) { s_min = s; n = 0; } - else if (k == k_min && get_context().get_random_value() % (++n) == 0) { + else if (k == k_min && ctx.get_random_value() % (++n) == 0) { s_min = s; } } @@ -3473,7 +3435,6 @@ void theory_seq::propagate_length_limit(expr* e) { */ void theory_seq::propagate_not_prefix(expr* e) { - context& ctx = get_context(); expr* e1 = nullptr, *e2 = nullptr; VERIFY(m_util.str.is_prefix(e, e1, e2)); literal lit = ctx.get_literal(e); @@ -3494,7 +3455,6 @@ void theory_seq::propagate_not_prefix(expr* e) { */ void theory_seq::propagate_not_suffix(expr* e) { - context& ctx = get_context(); expr* e1 = nullptr, *e2 = nullptr; VERIFY(m_util.str.is_suffix(e, e1, e2)); literal lit = ctx.get_literal(e); @@ -3512,7 +3472,6 @@ void theory_seq::propagate_not_suffix(expr* e) { } bool theory_seq::canonizes(bool is_true, expr* e) { - context& ctx = get_context(); dependency* deps = nullptr; expr_ref cont(m); if (!canonize(e, deps, cont)) cont = e; diff --git a/src/smt/theory_seq.h b/src/smt/theory_seq.h index ede35db7b..3bf28ecd9 100644 --- a/src/smt/theory_seq.h +++ b/src/smt/theory_seq.h @@ -367,8 +367,6 @@ namespace smt { }; typedef hashtable rational_set; - ast_manager& m; - theory_seq_params const& m_params; dependency_manager m_dm; solution_map m_rep; // unification representative. scoped_vector m_eqs; // set of current equations. @@ -427,7 +425,6 @@ namespace smt { obj_hashtable m_fixed; // string variables that are fixed length. obj_hashtable m_is_digit; // expressions that have been constrained to be digits - void init(context* ctx) override; final_check_status final_check_eh() override; bool internalize_atom(app* atom, bool) override; bool internalize_term(app*) override; @@ -443,7 +440,7 @@ namespace smt { void relevant_eh(app* n) override; bool should_research(expr_ref_vector &) override; void add_theory_assumptions(expr_ref_vector & assumptions) override; - theory* mk_fresh(context* new_ctx) override { return alloc(theory_seq, new_ctx->get_manager(), new_ctx->get_fparams()); } + theory* mk_fresh(context* new_ctx) override { return alloc(theory_seq, *new_ctx); } char const * get_name() const override { return "seq"; } bool include_func_interp(func_decl* f) override { return m_util.str.is_nth_u(f); } bool is_safe_to_copy(bool_var v) const override; @@ -683,9 +680,10 @@ namespace smt { std::ostream& display_nc(std::ostream& out, nc const& nc) const; std::ostream& display_lit(std::ostream& out, literal l) const; public: - theory_seq(ast_manager& m, theory_seq_params const & params); + theory_seq(context& ctx); ~theory_seq() override; + void init() override; // model building app* mk_value(app* a); diff --git a/src/smt/theory_seq_empty.h b/src/smt/theory_seq_empty.h index de04dfc0c..e06a5eaeb 100644 --- a/src/smt/theory_seq_empty.h +++ b/src/smt/theory_seq_empty.h @@ -33,11 +33,11 @@ namespace smt { bool internalize_term(app*) override { return internalize_atom(nullptr,false); } void new_eq_eh(theory_var, theory_var) override { } void new_diseq_eh(theory_var, theory_var) override {} - theory* mk_fresh(context* new_ctx) override { return alloc(theory_seq_empty, new_ctx->get_manager()); } + theory* mk_fresh(context* new_ctx) override { return alloc(theory_seq_empty, *new_ctx); } char const * get_name() const override { return "seq-empty"; } void display(std::ostream& out) const override {} public: - theory_seq_empty(ast_manager& m):theory(m.mk_family_id("seq")), m_used(false) {} + theory_seq_empty(context& ctx):theory(ctx, ctx.get_manager().mk_family_id("seq")), m_used(false) {} void init_model(model_generator & mg) override { mg.register_factory(alloc(seq_factory, get_manager(), get_family_id(), mg.get_model())); } diff --git a/src/smt/theory_special_relations.cpp b/src/smt/theory_special_relations.cpp index 3534ce610..439c61b26 100644 --- a/src/smt/theory_special_relations.cpp +++ b/src/smt/theory_special_relations.cpp @@ -90,8 +90,8 @@ namespace smt { return out; } - theory_special_relations::theory_special_relations(ast_manager& m): - theory(m.mk_family_id("special_relations")), + theory_special_relations::theory_special_relations(context& ctx, ast_manager& m): + theory(ctx, m.mk_family_id("special_relations")), m_util(m), m_can_propagate(false) { } @@ -101,7 +101,7 @@ namespace smt { } theory * theory_special_relations::mk_fresh(context * new_ctx) { - return alloc(theory_special_relations, new_ctx->get_manager()); + return alloc(theory_special_relations, *new_ctx, new_ctx->get_manager()); } /** @@ -112,7 +112,6 @@ namespace smt { assert f(term,c) or term != a */ void theory_special_relations::internalize_next(func_decl* f, app* term) { - context& ctx = get_context(); ast_manager& m = get_manager(); func_decl* nxt = term->get_decl(); expr* src = term->get_arg(0); @@ -143,7 +142,6 @@ namespace smt { m_relations.insert(atm->get_decl(), r); for (unsigned i = 0; i < m_atoms_lim.size(); ++i) r->push(); } - context& ctx = get_context(); expr* arg0 = atm->get_arg(0); expr* arg1 = atm->get_arg(1); theory_var v0 = mk_var(arg0); @@ -158,7 +156,6 @@ namespace smt { } theory_var theory_special_relations::mk_var(expr* e) { - context& ctx = get_context(); if (!ctx.e_internalized(e)) { ctx.internalize(e, false); } @@ -203,7 +200,7 @@ namespace smt { if (extract_equalities(*kv.m_value)) { new_equality = true; } - if (get_context().inconsistent()) { + if (ctx.inconsistent()) { return FC_CONTINUE; } } @@ -221,7 +218,6 @@ namespace smt { } enode* theory_special_relations::ensure_enode(expr* e) { - context& ctx = get_context(); if (!ctx.e_internalized(e)) { ctx.internalize(e, false); } @@ -233,7 +229,7 @@ namespace smt { literal theory_special_relations::mk_literal(expr* _e) { expr_ref e(_e, get_manager()); ensure_enode(e); - return get_context().get_literal(e); + return ctx.get_literal(e); } theory_var theory_special_relations::mk_var(enode* n) { @@ -242,8 +238,8 @@ namespace smt { } else { theory_var v = theory::mk_var(n); - get_context().attach_th_var(n, this, v); - get_context().mark_as_relevant(n); + ctx.attach_th_var(n, this, v); + ctx.mark_as_relevant(n); return v; } } @@ -270,7 +266,6 @@ namespace smt { // func_decl* tcf = r.decl(); func_decl* f = to_func_decl(tcf->get_parameter(0).get_ast()); - context& ctx = get_context(); ast_manager& m = get_manager(); bool new_assertion = false; graph r_graph; @@ -471,7 +466,6 @@ namespace smt { void theory_special_relations::set_conflict(relation& r) { literal_vector const& lits = r.m_explanation; - context & ctx = get_context(); TRACE("special_relations", ctx.display_literals_verbose(tout, lits) << "\n";); vector params; ctx.set_conflict( @@ -519,7 +513,6 @@ namespace smt { bool new_eq = false; int_vector scc_id; u_map roots; - context& ctx = get_context(); ast_manager& m = get_manager(); (void)m; r.m_graph.compute_zero_edge_scc(scc_id); @@ -950,7 +943,7 @@ namespace smt { for (atom* ap : r.m_asserted_atoms) { atom& a = *ap; if (!a.phase()) continue; - SASSERT(get_context().get_assignment(a.var()) == l_true); + SASSERT(ctx.get_assignment(a.var()) == l_true); expr* x = get_enode(a.v1())->get_root()->get_owner(); expr* y = get_enode(a.v2())->get_root()->get_owner(); expr* cb = connected_body; @@ -1151,7 +1144,6 @@ namespace smt { } void theory_special_relations::display_atom(std::ostream & out, atom& a) const { - context& ctx = get_context(); expr* e = ctx.bool_var2expr(a.var()); out << (a.phase() ? "" : "(not ") << mk_pp(e, get_manager()) << (a.phase() ? "" : ")") << "\n"; } diff --git a/src/smt/theory_special_relations.h b/src/smt/theory_special_relations.h index 8bf966009..f1ac66963 100644 --- a/src/smt/theory_special_relations.h +++ b/src/smt/theory_special_relations.h @@ -177,7 +177,7 @@ namespace smt { void internalize_next(func_decl* f, app * term); public: - theory_special_relations(ast_manager& m); + theory_special_relations(context& ctx, ast_manager& m); ~theory_special_relations() override; theory * mk_fresh(context * new_ctx) override; diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp index 41cd97f98..c9904996e 100644 --- a/src/smt/theory_str.cpp +++ b/src/smt/theory_str.cpp @@ -33,8 +33,23 @@ namespace smt { - theory_str::theory_str(ast_manager & m, theory_str_params const & params): - theory(m.mk_family_id("seq")), + + class seq_expr_solver : public expr_solver { + kernel m_kernel; + public: + seq_expr_solver(ast_manager& m, smt_params& fp): + m_kernel(m, fp) {} + lbool check_sat(expr* e) override { + m_kernel.push(); + m_kernel.assert_expr(e); + lbool r = m_kernel.check(); + m_kernel.pop(1); + return r; + } + }; + + theory_str::theory_str(context& ctx, ast_manager & m, theory_str_params const & params): + theory(ctx, m.mk_family_id("seq")), m_params(params), /* Options */ opt_EagerStringConstantLengthAssertions(true), @@ -63,7 +78,7 @@ namespace smt { tmpXorVarCount(0), avoidLoopCut(true), loopDetected(false), - m_theoryStrOverlapAssumption_term(m), + m_theoryStrOverlapAssumption_term(m.mk_true(), m), contains_map(m), string_int_conversion_terms(m), totalCacheAccessCount(0), @@ -76,7 +91,6 @@ namespace smt { fixed_length_assumptions(m), bitvector_character_constants(m) { - initialize_charset(); } theory_str::~theory_str() { @@ -87,6 +101,11 @@ namespace smt { regex_automata.clear(); } + void theory_str::init() { + initialize_charset(); + m_mk_aut.set_solver(alloc(seq_expr_solver, get_manager(), ctx.get_fparams())); + } + void theory_str::reset_internal_data_structures() { //m_trail.reset(); m_delayed_axiom_setup_terms.reset(); @@ -173,26 +192,6 @@ namespace smt { return u.str.mk_string(sym); } - class seq_expr_solver : public expr_solver { - kernel m_kernel; - public: - seq_expr_solver(ast_manager& m, smt_params& fp): - m_kernel(m, fp) {} - lbool check_sat(expr* e) override { - m_kernel.push(); - m_kernel.assert_expr(e); - lbool r = m_kernel.check(); - m_kernel.pop(1); - return r; - } - }; - - void theory_str::init(context * ctx) { - theory::init(ctx); - m_mk_aut.set_solver(alloc(seq_expr_solver, get_manager(), - get_context().get_fparams())); - } - void theory_str::collect_statistics(::statistics & st) const { st.update("str refine equation", m_stats.m_refine_eq); st.update("str refine negated equation", m_stats.m_refine_neq); @@ -281,7 +280,6 @@ namespace smt { } if (get_manager().is_true(_e)) return; - context & ctx = get_context(); ast_manager& m = get_manager(); TRACE("str", tout << "asserting " << mk_ismt2_pp(_e, m) << std::endl;); expr_ref e(_e, m); @@ -305,7 +303,6 @@ namespace smt { void theory_str::assert_axiom_rw(expr * e) { if (e == nullptr) return; - context & ctx = get_context(); ast_manager & m = get_manager(); expr_ref _e(e, m); ctx.get_rewriter()(_e); @@ -329,7 +326,6 @@ namespace smt { } bool theory_str::internalize_term(app * term) { - context & ctx = get_context(); ast_manager & m = get_manager(); SASSERT(term->get_family_id() == get_family_id()); @@ -371,7 +367,6 @@ namespace smt { } enode* theory_str::ensure_enode(expr* e) { - context& ctx = get_context(); if (!ctx.e_internalized(e)) { ctx.internalize(e, false); } @@ -403,8 +398,8 @@ namespace smt { theory_var v = theory::mk_var(n); m_find.mk_var(); TRACE("str", tout << "new theory var v#" << v << " find " << m_find.find(v) << std::endl;); - get_context().attach_th_var(n, this, v); - get_context().mark_as_relevant(n); + ctx.attach_th_var(n, this, v); + ctx.mark_as_relevant(n); return v; } } @@ -522,7 +517,6 @@ namespace smt { literal theory_str::mk_literal(expr* _e) { ast_manager & m = get_manager(); expr_ref e(_e, m); - context& ctx = get_context(); ensure_enode(e); return ctx.get_literal(e); } @@ -557,7 +551,6 @@ namespace smt { app * theory_str::mk_int_var(std::string name) { - context & ctx = get_context(); ast_manager & m = get_manager(); TRACE("str", tout << "creating integer variable " << name << " at scope level " << sLevel << std::endl;); @@ -581,7 +574,6 @@ namespace smt { } app * theory_str::mk_str_var(std::string name) { - context & ctx = get_context(); TRACE("str", tout << "creating string variable " << name << " at scope level " << sLevel << std::endl;); @@ -609,7 +601,6 @@ namespace smt { } void theory_str::add_nonempty_constraint(expr * s) { - context & ctx = get_context(); ast_manager & m = get_manager(); expr_ref ax1(mk_not(m, ctx.mk_eq_atom(s, mk_string(""))), m); @@ -631,7 +622,6 @@ namespace smt { } app_ref theory_str::mk_nonempty_str_var() { - context & ctx = get_context(); ast_manager & m = get_manager(); std::stringstream ss; @@ -677,7 +667,7 @@ namespace smt { app * contains = u.str.mk_contains(haystack, needle); // TODO double-check semantics/argument order m_trail.push_back(contains); // immediately force internalization so that axiom setup does not fail - get_context().internalize(contains, false); + ctx.internalize(contains, false); set_up_axioms(contains); return contains; } @@ -687,7 +677,7 @@ namespace smt { app * indexof = u.str.mk_index(haystack, needle, mk_int(0)); m_trail.push_back(indexof); // immediately force internalization so that axiom setup does not fail - get_context().internalize(indexof, false); + ctx.internalize(indexof, false); set_up_axioms(indexof); return indexof; } @@ -757,7 +747,6 @@ namespace smt { } expr * theory_str::mk_concat(expr * n1, expr * n2) { - context & ctx = get_context(); ast_manager & m = get_manager(); ENSURE(n1 != nullptr); ENSURE(n2 != nullptr); @@ -850,7 +839,6 @@ namespace smt { } void theory_str::propagate() { - context & ctx = get_context(); candidate_model.reset(); while (can_propagate()) { TRACE("str", tout << "propagating..." << std::endl;); @@ -960,7 +948,6 @@ namespace smt { app * a_cat = cat->get_owner(); SASSERT(u.str.is_concat(a_cat)); - context & ctx = get_context(); ast_manager & m = get_manager(); TRACE("str", tout << "attempting to flatten " << mk_pp(a_cat, m) << std::endl;); @@ -1051,7 +1038,6 @@ namespace smt { * Length(x) == strlen(x) */ void theory_str::instantiate_basic_string_axioms(enode * str) { - context & ctx = get_context(); ast_manager & m = get_manager(); TRACE("str", tout << "set up basic string axioms on " << mk_pp(str->get_owner(), m) << std::endl;); @@ -1144,7 +1130,6 @@ namespace smt { * (lhs == rhs) -> ( Length(lhs) == Length(rhs) ) */ void theory_str::instantiate_str_eq_length_axiom(enode * lhs, enode * rhs) { - context & ctx = get_context(); ast_manager & m = get_manager(); app * a_lhs = lhs->get_owner(); @@ -1166,7 +1151,6 @@ namespace smt { } void theory_str::instantiate_axiom_CharAt(enode * e) { - context & ctx = get_context(); ast_manager & m = get_manager(); expr* arg0, *arg1; app * expr = e->get_owner(); @@ -1197,12 +1181,11 @@ namespace smt { expr_ref axiom(m.mk_ite(cond, thenBranch, elseBranch), m); expr_ref reductionVar(ctx.mk_eq_atom(expr, ts1), m); expr_ref finalAxiom(m.mk_and(axiom, reductionVar), m); - get_context().get_rewriter()(finalAxiom); + ctx.get_rewriter()(finalAxiom); assert_axiom(finalAxiom); } void theory_str::instantiate_axiom_prefixof(enode * e) { - context & ctx = get_context(); ast_manager & m = get_manager(); app * expr = e->get_owner(); @@ -1239,7 +1222,6 @@ namespace smt { } void theory_str::instantiate_axiom_suffixof(enode * e) { - context & ctx = get_context(); ast_manager & m = get_manager(); app * expr = e->get_owner(); @@ -1276,7 +1258,6 @@ namespace smt { } void theory_str::instantiate_axiom_Contains(enode * e) { - context & ctx = get_context(); ast_manager & m = get_manager(); app * ex = e->get_owner(); @@ -1326,7 +1307,6 @@ namespace smt { } void theory_str::instantiate_axiom_Indexof(enode * e) { - context & ctx = get_context(); th_rewriter & rw = ctx.get_rewriter(); ast_manager & m = get_manager(); @@ -1429,7 +1409,6 @@ namespace smt { } void theory_str::instantiate_axiom_Indexof_extended(enode * _e) { - context & ctx = get_context(); th_rewriter & rw = ctx.get_rewriter(); ast_manager & m = get_manager(); @@ -1581,7 +1560,6 @@ namespace smt { } void theory_str::instantiate_axiom_LastIndexof(enode * e) { - context & ctx = get_context(); ast_manager & m = get_manager(); app * expr = e->get_owner(); @@ -1650,7 +1628,6 @@ namespace smt { } void theory_str::instantiate_axiom_Substr(enode * e) { - context & ctx = get_context(); ast_manager & m = get_manager(); expr* substrBase = nullptr; expr* substrPos = nullptr; @@ -1743,7 +1720,6 @@ namespace smt { // of t in s, if any, by t'. Note that if t is empty, the result is to prepend // t' to s; also, if t does not occur in s then the result is s. void theory_str::instantiate_axiom_Replace(enode * e) { - context & ctx = get_context(); ast_manager & m = get_manager(); app * ex = e->get_owner(); @@ -1805,7 +1781,6 @@ namespace smt { } void theory_str::instantiate_axiom_str_to_int(enode * e) { - context & ctx = get_context(); ast_manager & m = get_manager(); app * ex = e->get_owner(); @@ -1851,7 +1826,6 @@ namespace smt { } void theory_str::instantiate_axiom_int_to_str(enode * e) { - context & ctx = get_context(); ast_manager & m = get_manager(); app * ex = e->get_owner(); @@ -1889,7 +1863,7 @@ namespace smt { expr * theory_str::mk_RegexIn(expr * str, expr * regexp) { app * regexIn = u.re.mk_in_re(str, regexp); // immediately force internalization so that axiom setup does not fail - get_context().internalize(regexIn, false); + ctx.internalize(regexIn, false); set_up_axioms(regexIn); return regexIn; } @@ -1916,7 +1890,6 @@ namespace smt { } void theory_str::attach_new_th_var(enode * n) { - context & ctx = get_context(); theory_var v = mk_var(n); ctx.attach_th_var(n, this, v); TRACE("str", tout << "new theory var: " << mk_ismt2_pp(n->get_owner(), get_manager()) << " := v#" << v << std::endl;); @@ -1929,7 +1902,7 @@ namespace smt { candidate_model.reset(); m_basicstr_axiom_todo.reset(); m_concat_axiom_todo.reset(); - pop_scope_eh(get_context().get_scope_level()); + pop_scope_eh(ctx.get_scope_level()); } /* @@ -1943,7 +1916,6 @@ namespace smt { * Then add an assertion: (y2 == (Concat ce m2)) AND ("str3" == (Concat abc x2)) -> (y2 != "str3") */ bool theory_str::new_eq_check(expr * lhs, expr * rhs) { - context & ctx = get_context(); ast_manager & m = get_manager(); // skip this check if we defer consistency checking, as we can do it for every EQC in final check @@ -2001,7 +1973,6 @@ namespace smt { if (!is_app(n)) { return null_theory_var; } - context & ctx = get_context(); if (ctx.e_internalized(to_app(n))) { enode * e = ctx.get_enode(to_app(n)); return e->get_th_var(get_id()); @@ -2113,7 +2084,6 @@ namespace smt { */ void theory_str::simplify_parent(expr * nn, expr * eq_str) { ast_manager & m = get_manager(); - context & ctx = get_context(); TRACE("str", tout << "simplifying parents of " << mk_ismt2_pp(nn, m) << " with respect to " << mk_ismt2_pp(eq_str, m) << std::endl;); @@ -2405,7 +2375,6 @@ namespace smt { expr * theory_str::simplify_concat(expr * node) { ast_manager & m = get_manager(); - context & ctx = get_context(); std::map resolvedMap; ptr_vector argVec; get_nodes_in_concat(node, argVec); @@ -2453,7 +2422,6 @@ namespace smt { // (i.e. the equivalent of a len_exists flag in get_len_value()). bool theory_str::infer_len_concat(expr * n, rational & nLen) { - context & ctx = get_context(); ast_manager & m = get_manager(); expr * arg0 = to_app(n)->get_arg(0); expr * arg1 = to_app(n)->get_arg(1); @@ -2493,7 +2461,6 @@ namespace smt { return; } - context & ctx = get_context(); ast_manager & m = get_manager(); expr * arg0 = to_app(n)->get_arg(0); @@ -2602,14 +2569,12 @@ namespace smt { } void theory_str::add_theory_aware_branching_info(expr * term, double priority, lbool phase) { - context & ctx = get_context(); ctx.internalize(term, false); bool_var v = ctx.get_bool_var(term); ctx.add_theory_aware_branching_info(v, priority, phase); } void theory_str::generate_mutual_exclusion(expr_ref_vector & terms) { - context & ctx = get_context(); // pull each literal out of the arrangement disjunction literal_vector ls; for (expr * e : terms) { @@ -2638,7 +2603,6 @@ namespace smt { */ void theory_str::simplify_concat_equality(expr * nn1, expr * nn2) { ast_manager & m = get_manager(); - context & ctx = get_context(); app * a_nn1 = to_app(nn1); SASSERT(a_nn1->get_num_args() == 2); @@ -3048,7 +3012,6 @@ namespace smt { void theory_str::process_concat_eq_type1(expr * concatAst1, expr * concatAst2) { ast_manager & mgr = get_manager(); - context & ctx = get_context(); bool overlapAssumptionUsed = false; @@ -3440,7 +3403,6 @@ namespace smt { void theory_str::process_concat_eq_type2(expr * concatAst1, expr * concatAst2) { ast_manager & mgr = get_manager(); - context & ctx = get_context(); bool overlapAssumptionUsed = false; @@ -3792,7 +3754,6 @@ namespace smt { void theory_str::process_concat_eq_type3(expr * concatAst1, expr * concatAst2) { ast_manager & mgr = get_manager(); - context & ctx = get_context(); bool overlapAssumptionUsed = false; @@ -4141,7 +4102,6 @@ namespace smt { void theory_str::process_concat_eq_type4(expr * concatAst1, expr * concatAst2) { ast_manager & mgr = get_manager(); - context & ctx = get_context(); TRACE("str", tout << "process_concat_eq TYPE 4" << std::endl << "concatAst1 = " << mk_ismt2_pp(concatAst1, mgr) << std::endl << "concatAst2 = " << mk_ismt2_pp(concatAst2, mgr) << std::endl; @@ -4242,7 +4202,6 @@ namespace smt { void theory_str::process_concat_eq_type5(expr * concatAst1, expr * concatAst2) { ast_manager & mgr = get_manager(); - context & ctx = get_context(); TRACE("str", tout << "process_concat_eq TYPE 5" << std::endl << "concatAst1 = " << mk_ismt2_pp(concatAst1, mgr) << std::endl << "concatAst2 = " << mk_ismt2_pp(concatAst2, mgr) << std::endl; @@ -4343,7 +4302,6 @@ namespace smt { void theory_str::process_concat_eq_type6(expr * concatAst1, expr * concatAst2) { ast_manager & mgr = get_manager(); - context & ctx = get_context(); TRACE("str", tout << "process_concat_eq TYPE 6" << std::endl << "concatAst1 = " << mk_ismt2_pp(concatAst1, mgr) << std::endl << "concatAst2 = " << mk_ismt2_pp(concatAst2, mgr) << std::endl; @@ -4588,7 +4546,6 @@ namespace smt { } bool theory_str::get_arith_value(expr* e, rational& val) const { - context& ctx = get_context(); ast_manager & m = get_manager(); (void)m; if (!ctx.e_internalized(e)) { @@ -4615,7 +4572,7 @@ namespace smt { } arith_value v(get_manager()); - v.init(&get_context()); + v.init(&ctx); bool strict; return v.get_lo_equiv(_e, lo, strict); } @@ -4627,7 +4584,7 @@ namespace smt { } arith_value v(get_manager()); - v.init(&get_context()); + v.init(&ctx); bool strict; return v.get_up_equiv(_e, hi, strict); } @@ -4638,7 +4595,6 @@ namespace smt { return false; } - context& ctx = get_context(); ast_manager & m = get_manager(); TRACE("str", tout << "checking len value of " << mk_ismt2_pp(e, m) << std::endl;); @@ -4713,7 +4669,6 @@ namespace smt { */ bool theory_str::in_same_eqc(expr * n1, expr * n2) { if (n1 == n2) return true; - context & ctx = get_context(); // similar to get_eqc_value(), make absolutely sure // that we've set this up properly for the context @@ -4769,7 +4724,6 @@ namespace smt { } void theory_str::check_contain_by_eqc_val(expr * varNode, expr * constNode) { - context & ctx = get_context(); ast_manager & m = get_manager(); TRACE("str", tout << "varNode = " << mk_pp(varNode, m) << ", constNode = " << mk_pp(constNode, m) << std::endl;); @@ -4903,7 +4857,6 @@ namespace smt { } void theory_str::check_contain_by_substr(expr * varNode, expr_ref_vector & willEqClass) { - context & ctx = get_context(); ast_manager & m = get_manager(); expr_ref_vector litems(m); @@ -4977,7 +4930,6 @@ namespace smt { } void theory_str::check_contain_by_eq_nodes(expr * n1, expr * n2) { - context & ctx = get_context(); ast_manager & m = get_manager(); if (in_contain_idx_map(n1) && in_contain_idx_map(n2)) { @@ -5409,7 +5361,6 @@ namespace smt { // haven't computed grounded concats for "node" (de-aliased) // --------------------------------------------------------- - context & ctx = get_context(); // const strings: node is de-aliased if (u.str.is_string(node)) { @@ -5639,7 +5590,6 @@ namespace smt { void theory_str::check_subsequence(expr* str, expr* strDeAlias, expr* subStr, expr* subStrDeAlias, expr* boolVar, std::map, std::set > > & groundedMap) { - context & ctx = get_context(); ast_manager & m = get_manager(); std::map, std::set >::iterator itorStr = groundedMap[strDeAlias].begin(); std::map, std::set >::iterator itorSubStr; @@ -5840,7 +5790,6 @@ namespace smt { // - note that these are different from the semantics in Z3str2 bool theory_str::check_length_const_string(expr * n1, expr * constStr) { ast_manager & mgr = get_manager(); - context & ctx = get_context(); zstring tmp; u.str.is_string(constStr, tmp); @@ -5892,7 +5841,6 @@ namespace smt { } bool theory_str::check_length_concat_concat(expr * n1, expr * n2) { - context & ctx = get_context(); ast_manager & mgr = get_manager(); ptr_vector concat1Args; @@ -5963,7 +5911,6 @@ namespace smt { } bool theory_str::check_length_concat_var(expr * concat, expr * var) { - context & ctx = get_context(); ast_manager & mgr = get_manager(); rational varLen; @@ -5999,7 +5946,6 @@ namespace smt { } bool theory_str::check_length_var_var(expr * var1, expr * var2) { - context & ctx = get_context(); ast_manager & mgr = get_manager(); rational var1Len, var2Len; @@ -6283,7 +6229,6 @@ namespace smt { */ void theory_str::solve_concat_eq_str(expr * concat, expr * str) { ast_manager & m = get_manager(); - context & ctx = get_context(); TRACE("str", tout << mk_ismt2_pp(concat, m) << " == " << mk_ismt2_pp(str, m) << std::endl;); @@ -6620,7 +6565,6 @@ namespace smt { void theory_str::handle_equality(expr * lhs, expr * rhs) { ast_manager & m = get_manager(); - context & ctx = get_context(); // both terms must be of sort String sort * lhs_sort = m.get_sort(lhs); sort * rhs_sort = m.get_sort(rhs); @@ -6768,7 +6712,6 @@ namespace smt { // Check that a string's length can be 0 iff it is the empty string. void theory_str::check_eqc_empty_string(expr * lhs, expr * rhs) { - context & ctx = get_context(); ast_manager & m = get_manager(); rational nn1Len, nn2Len; @@ -6864,7 +6807,6 @@ namespace smt { void theory_str::set_up_axioms(expr * ex) { ast_manager & m = get_manager(); - context & ctx = get_context(); // workaround for #3756: // the map existing_toplevel_exprs is never cleared on backtracking. @@ -6982,13 +6924,13 @@ namespace smt { lbool theory_str::validate_unsat_core(expr_ref_vector & unsat_core) { app * target_term = to_app(get_manager().mk_not(m_theoryStrOverlapAssumption_term)); - get_context().internalize(target_term, false); - enode* e1 = get_context().get_enode(target_term); + ctx.internalize(target_term, false); + enode* e1 = ctx.get_enode(target_term); for (unsigned i = 0; i < unsat_core.size(); ++i) { app * core_term = to_app(unsat_core.get(i)); // not sure if this is the correct way to compare terms in this context - if (!get_context().e_internalized(core_term)) continue; - enode *e2 = get_context().get_enode(core_term); + if (!ctx.e_internalized(core_term)) continue; + enode *e2 = ctx.get_enode(core_term); if (e1 == e2) { TRACE("str", tout << "overlap detected in unsat core, changing UNSAT to UNKNOWN" << std::endl;); return l_undef; @@ -6999,7 +6941,6 @@ namespace smt { } void theory_str::init_search_eh() { - context & ctx = get_context(); reset_internal_data_structures(); @@ -7067,7 +7008,7 @@ namespace smt { void theory_str::assign_eh(bool_var v, bool is_true) { candidate_model.reset(); - expr * e = get_context().bool_var2expr(v); + expr * e = ctx.bool_var2expr(v); TRACE("str", tout << "assert: v" << v << " " << mk_pp(e, get_manager()) << " is_true: " << is_true << std::endl;); DEBUG_CODE( for (auto * f : existing_toplevel_exprs) { @@ -7131,7 +7072,6 @@ namespace smt { TRACE("str", tout << "checking scopes of variables in the current assignment" << std::endl;); - context & ctx = get_context(); ast_manager & m = get_manager(); expr_ref_vector assignments(m); @@ -7147,7 +7087,6 @@ namespace smt { } void theory_str::pop_scope_eh(unsigned num_scopes) { - context & ctx = get_context(); sLevel -= num_scopes; TRACE("str", tout << "pop " << num_scopes << " to " << sLevel << std::endl;); candidate_model.reset(); @@ -7209,7 +7148,6 @@ namespace smt { void theory_str::dump_assignments() { TRACE_CODE( ast_manager & m = get_manager(); - context & ctx = get_context(); tout << "dumping all assignments:" << std::endl; expr_ref_vector assignments(m); ctx.get_assignments(assignments); @@ -7294,7 +7232,6 @@ namespace smt { void theory_str::classify_ast_by_type_in_positive_context(std::map & varMap, std::map & concatMap, std::map & unrollMap) { - context & ctx = get_context(); ast_manager & m = get_manager(); expr_ref_vector assignments(m); ctx.get_assignments(assignments); @@ -7352,7 +7289,6 @@ namespace smt { std::map > & concat_eq_concat_map, std::map > & unrollGroupMap) { #ifdef _TRACE - context & ctx = get_context(); ast_manager & mgr = get_manager(); { tout << "(0) alias: variables" << std::endl; @@ -7517,7 +7453,6 @@ namespace smt { std::map > concat_eq_concat_map; std::map > depMap; - context & ctx = get_context(); ast_manager & m = get_manager(); // note that the old API concatenated these assignments into @@ -8071,7 +8006,6 @@ namespace smt { bool theory_str::finalcheck_str2int(app * a) { SASSERT(u.str.is_stoi(a)); bool axiomAdd = false; - context & ctx = get_context(); ast_manager & m = get_manager(); expr * S = a->get_arg(0); @@ -8156,7 +8090,6 @@ namespace smt { bool theory_str::finalcheck_int2str(app * a) { bool axiomAdd = false; - context & ctx = get_context(); ast_manager & m = get_manager(); expr * N = a->get_arg(0); @@ -8247,7 +8180,6 @@ namespace smt { bool theory_str::propagate_length_within_eqc(expr * var) { bool res = false; ast_manager & m = get_manager(); - context & ctx = get_context(); TRACE("str", tout << "propagate_length_within_eqc: " << mk_ismt2_pp(var, m) << std::endl ;); @@ -8286,7 +8218,6 @@ namespace smt { } bool theory_str::propagate_length(std::set & varSet, std::set & concatSet, std::map & exprLenMap) { - context & ctx = get_context(); ast_manager & m = get_manager(); expr_ref_vector assignments(m); ctx.get_assignments(assignments); @@ -8370,7 +8301,6 @@ namespace smt { } final_check_status theory_str::final_check_eh() { - context & ctx = get_context(); ast_manager & m = get_manager(); //expr_ref_vector assignments(m); @@ -8723,7 +8653,7 @@ namespace smt { TRACE("str", tout << "using fixed-length model construction" << std::endl;); arith_value v(get_manager()); - v.init(&get_context()); + v.init(&ctx); final_check_status arith_fc_status = v.final_check(); if (arith_fc_status != FC_DONE) { TRACE("str", tout << "arithmetic solver not done yet, continuing search" << std::endl;); @@ -8884,7 +8814,7 @@ namespace smt { owner = n->get_owner(); // If the owner is not internalized, it doesn't have an enode associated. - SASSERT(get_context().e_internalized(owner)); + SASSERT(ctx.e_internalized(owner)); app * val = mk_value_helper(owner); if (val != nullptr) { @@ -8905,7 +8835,6 @@ namespace smt { unsigned theory_str::get_refine_length(expr* ex, expr_ref_vector& extra_deps){ ast_manager & m = get_manager(); - context & ctx = get_context(); TRACE("str_fl", tout << "finding length for " << mk_ismt2_pp(ex, m) << std::endl;); if (u.str.is_string(ex)) { @@ -8991,7 +8920,6 @@ namespace smt { expr* theory_str::refine_eq(expr* lhs, expr* rhs, unsigned offset) { TRACE("str_fl", tout << "refine eq " << offset << std::endl;); ast_manager & m = get_manager(); - context & ctx = get_context(); expr_ref_vector Gamma(m); expr_ref_vector Delta(m); @@ -9112,7 +9040,6 @@ namespace smt { expr* theory_str::refine_dis(expr* lhs, expr* rhs) { ast_manager & m = get_manager(); - context & ctx = get_context(); expr_ref lesson(m); lesson = m.mk_not(ctx.mk_eq_atom(lhs, rhs)); diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h index 3d3208ca5..34f371219 100644 --- a/src/smt/theory_str.h +++ b/src/smt/theory_str.h @@ -778,10 +778,11 @@ protected: void refresh_theory_var(expr * e); public: - theory_str(ast_manager & m, theory_str_params const & params); + theory_str(context& ctx, ast_manager & m, theory_str_params const & params); ~theory_str() override; char const * get_name() const override { return "seq"; } + void init() override; void display(std::ostream & out) const override; void collect_statistics(::statistics & st) const override; @@ -801,8 +802,7 @@ protected: void new_eq_eh(theory_var, theory_var) override; void new_diseq_eh(theory_var, theory_var) override; - theory* mk_fresh(context* c) override { return alloc(theory_str, c->get_manager(), m_params); } - void init(context * ctx) override; + theory* mk_fresh(context* c) override { return alloc(theory_str, *c, c->get_manager(), m_params); } void init_search_eh() override; void add_theory_assumptions(expr_ref_vector & assumptions) override; lbool validate_unsat_core(expr_ref_vector & unsat_core) override; diff --git a/src/smt/theory_str_mc.cpp b/src/smt/theory_str_mc.cpp index 2ca1482d7..9949ac740 100644 --- a/src/smt/theory_str_mc.cpp +++ b/src/smt/theory_str_mc.cpp @@ -88,7 +88,6 @@ namespace smt { bool theory_str::fixed_length_reduce_suffix(smt::kernel & subsolver, expr_ref f, expr_ref & cex) { ast_manager & m = get_manager(); - context & ctx = get_context(); ast_manager & sub_m = subsolver.m(); context & sub_ctx = subsolver.get_context(); @@ -151,7 +150,6 @@ namespace smt { bool theory_str::fixed_length_reduce_negative_suffix(smt::kernel & subsolver, expr_ref f, expr_ref & cex) { ast_manager & m = get_manager(); - context & ctx = get_context(); ast_manager & sub_m = subsolver.m(); context & sub_ctx = subsolver.get_context(); @@ -206,7 +204,6 @@ namespace smt { bool theory_str::fixed_length_reduce_prefix(smt::kernel & subsolver, expr_ref f, expr_ref & cex) { ast_manager & m = get_manager(); - context & ctx = get_context(); ast_manager & sub_m = subsolver.m(); context & sub_ctx = subsolver.get_context(); @@ -269,7 +266,6 @@ namespace smt { bool theory_str::fixed_length_reduce_negative_prefix(smt::kernel & subsolver, expr_ref f, expr_ref & cex) { ast_manager & m = get_manager(); - context & ctx = get_context(); ast_manager & sub_m = subsolver.m(); context & sub_ctx = subsolver.get_context(); @@ -323,7 +319,6 @@ namespace smt { bool theory_str::fixed_length_reduce_contains(smt::kernel & subsolver, expr_ref f, expr_ref & cex) { ast_manager & m = get_manager(); - context & ctx = get_context(); ast_manager & sub_m = subsolver.m(); context & sub_ctx = subsolver.get_context(); @@ -391,7 +386,6 @@ namespace smt { bool theory_str::fixed_length_reduce_negative_contains(smt::kernel & subsolver, expr_ref f, expr_ref & cex) { ast_manager & m = get_manager(); - context & ctx = get_context(); ast_manager & sub_m = subsolver.m(); context & sub_ctx = subsolver.get_context(); @@ -463,7 +457,6 @@ namespace smt { bool theory_str::fixed_length_reduce_regex_membership(smt::kernel & subsolver, expr_ref f, expr_ref & cex, bool polarity) { ast_manager & m = get_manager(); - context & ctx = get_context(); ast_manager & sub_m = subsolver.m(); context & sub_ctx = subsolver.get_context(); @@ -776,7 +769,6 @@ namespace smt { bool theory_str::fixed_length_reduce_eq(smt::kernel & subsolver, expr_ref lhs, expr_ref rhs, expr_ref & cex) { ast_manager & m = get_manager(); - context & ctx = get_context(); ast_manager & sub_m = subsolver.m(); context & sub_ctx = subsolver.get_context(); @@ -873,7 +865,6 @@ namespace smt { TRACE("str", ast_manager & m = get_manager(); - context & ctx = get_context(); tout << "dumping all formulas:" << std::endl; for (expr_ref_vector::iterator i = formulas.begin(); i != formulas.end(); ++i) { expr * ex = *i; @@ -1154,7 +1145,6 @@ namespace smt { if (m.is_true(f_new)) { // do nothing } else if (m.is_false(f_new)) { - context & ctx = get_context(); expr * needle = nullptr, *haystack = nullptr; if (u.str.is_contains(f, haystack, needle)) { expr_ref haystack_assignment(m); diff --git a/src/smt/theory_str_regex.cpp b/src/smt/theory_str_regex.cpp index 0b5d831fc..bdf27943e 100644 --- a/src/smt/theory_str_regex.cpp +++ b/src/smt/theory_str_regex.cpp @@ -48,7 +48,6 @@ namespace smt { void theory_str::solve_regex_automata() { - context & ctx = get_context(); ast_manager & m = get_manager(); // TODO since heuristics might fail, the "no progress" flag might need to be handled specially here @@ -999,7 +998,6 @@ namespace smt { */ expr_ref theory_str::infer_all_regex_lengths(expr * lenVar, expr * re, expr_ref_vector & freeVariables) { ENSURE(u.is_re(re)); - context & ctx = get_context(); ast_manager & m = get_manager(); expr * sub1; expr * sub2; @@ -1127,7 +1125,6 @@ namespace smt { */ void theory_str::find_automaton_initial_bounds(expr * str_in_re, eautomaton * aut) { ENSURE(aut != nullptr); - context & ctx = get_context(); ast_manager & m = get_manager(); expr_ref_vector rhs(m); @@ -1362,7 +1359,6 @@ namespace smt { } expr_ref theory_str::aut_path_rewrite_constraint(expr * cond, expr * ch_var) { - context & ctx = get_context(); ast_manager & m = get_manager(); expr_ref retval(m); @@ -1419,7 +1415,6 @@ namespace smt { */ expr_ref theory_str::generate_regex_path_constraints(expr * stringTerm, eautomaton * aut, rational lenVal, expr_ref & characterConstraints) { ENSURE(aut != nullptr); - context & ctx = get_context(); ast_manager & m = get_manager(); if (lenVal.is_zero()) { diff --git a/src/smt/theory_utvpi.h b/src/smt/theory_utvpi.h index e75706376..531a99dd2 100644 --- a/src/smt/theory_utvpi.h +++ b/src/smt/theory_utvpi.h @@ -199,21 +199,21 @@ namespace smt { } public: - theory_utvpi(ast_manager& m); + theory_utvpi(context& ctx); ~theory_utvpi() override; theory * mk_fresh(context * new_ctx) override; char const * get_name() const override { return "utvpi-logic"; } + + void init() override { init_zero(); } /** \brief See comment in theory::mk_eq_atom */ app * mk_eq_atom(expr * lhs, expr * rhs) override { return a.mk_eq(lhs, rhs); } - void init(context * ctx) override; - bool internalize_atom(app * atom, bool gate_ctx) override; bool internalize_term(app * term) override; diff --git a/src/smt/theory_utvpi_def.h b/src/smt/theory_utvpi_def.h index ee22b50f0..74d476d88 100644 --- a/src/smt/theory_utvpi_def.h +++ b/src/smt/theory_utvpi_def.h @@ -57,10 +57,10 @@ namespace smt { template - theory_utvpi::theory_utvpi(ast_manager& m): - theory(m.mk_family_id("arith")), - a(m), - m_arith_eq_adapter(*this, m_params, a), + theory_utvpi::theory_utvpi(context& ctx): + theory(ctx, ctx.get_manager().mk_family_id("arith")), + a(ctx.get_manager()), + m_arith_eq_adapter(*this, a), m_consistent(true), m_izero(null_theory_var), m_rzero(null_theory_var), @@ -70,7 +70,7 @@ namespace smt { m_lia(false), m_lra(false), m_non_utvpi_exprs(false), - m_test(m), + m_test(ctx.get_manager()), m_factory(nullptr), m_var_value_table(DEFAULT_HASHTABLE_INITIAL_CAPACITY, var_value_hash(*this), var_value_eq(*this)) { } @@ -98,16 +98,15 @@ namespace smt { template theory_var theory_utvpi::mk_var(enode* n) { th_var v = theory::mk_var(n); - TRACE("utvpi", tout << v << " " << mk_pp(n->get_owner(), get_manager()) << "\n";); + TRACE("utvpi", tout << v << " " << mk_pp(n->get_owner(), m) << "\n";); m_graph.init_var(to_var(v)); m_graph.init_var(neg(to_var(v))); - get_context().attach_th_var(n, this, v); + ctx.attach_th_var(n, this, v); return v; } template theory_var theory_utvpi::mk_var(expr* n) { - context & ctx = get_context(); enode* e = nullptr; th_var v = null_theory_var; m_lia |= a.is_int(n); @@ -154,8 +153,6 @@ namespace smt { rational k(0); th_var s = expand(true, v1, k); th_var t = expand(false, v2, k); - context& ctx = get_context(); - ast_manager& m = get_manager(); if (s == t) { if (is_eq != k.is_zero()) { @@ -193,7 +190,7 @@ namespace smt { template void theory_utvpi::inc_conflicts() { - get_context().push_trail(value_trail(m_consistent)); + ctx.push_trail(value_trail(m_consistent)); m_consistent = false; m_stats.m_num_conflicts++; if (m_params.m_arith_adaptive) { @@ -206,7 +203,6 @@ namespace smt { void theory_utvpi::set_conflict() { inc_conflicts(); literal_vector const& lits = m_nc_functor.get_lits(); - context & ctx = get_context(); IF_VERBOSE(20, ctx.display_literals_smt2(verbose_stream() << "conflict:\n", lits)); TRACE("utvpi", ctx.display_literals_smt2(tout << "conflict:\n", lits);); @@ -216,7 +212,7 @@ namespace smt { } vector params; - if (get_manager().proofs_enabled()) { + if (m.proofs_enabled()) { params.push_back(parameter(symbol("farkas"))); for (unsigned i = 0; i < m_nc_functor.get_coeffs().size(); ++i) { params.push_back(parameter(rational(m_nc_functor.get_coeffs()[i]))); @@ -238,24 +234,18 @@ namespace smt { return; } std::stringstream msg; - msg << "found non utvpi logic expression:\n" << mk_pp(n, get_manager()) << "\n"; + msg << "found non utvpi logic expression:\n" << mk_pp(n, m) << "\n"; TRACE("utvpi", tout << msg.str();); warning_msg("%s", msg.str().c_str()); - get_context().push_trail(value_trail(m_non_utvpi_exprs)); + ctx.push_trail(value_trail(m_non_utvpi_exprs)); m_non_utvpi_exprs = true; } - template - void theory_utvpi::init(context* ctx) { - theory::init(ctx); - init_zero(); - } - template void theory_utvpi::init_zero() { if (m_izero == null_theory_var) { - m_izero = mk_var(get_context().mk_enode(a.mk_numeral(rational(0), true), false, false, true)); - m_rzero = mk_var(get_context().mk_enode(a.mk_numeral(rational(0), false), false, false, true)); + m_izero = mk_var(ctx.mk_enode(a.mk_numeral(rational(0), true), false, false, true)); + m_rzero = mk_var(ctx.mk_enode(a.mk_numeral(rational(0), false), false, false, true)); } } @@ -297,7 +287,6 @@ namespace smt { template void theory_utvpi::internalize_eq_eh(app * atom, bool_var v) { - context & ctx = get_context(); app * lhs = to_app(atom->get_arg(0)); app * rhs = to_app(atom->get_arg(1)); if (a.is_numeral(rhs)) { @@ -317,7 +306,6 @@ namespace smt { bool theory_utvpi::internalize_atom(app * n, bool) { if (!m_consistent) return false; - context & ctx = get_context(); if (!a.is_le(n) && !a.is_ge(n) && !a.is_lt(n) && !a.is_gt(n)) { found_non_utvpi_expr(n); return false; @@ -357,7 +345,7 @@ namespace smt { m_atoms.push_back(atom(bv, pos, neg)); TRACE("utvpi", - tout << mk_pp(n, get_manager()) << "\n"; + tout << mk_pp(n, m) << "\n"; m_graph.display_edge(tout << "pos: ", pos); m_graph.display_edge(tout << "neg: ", neg); ); @@ -369,8 +357,8 @@ namespace smt { bool theory_utvpi::internalize_term(app * term) { if (!m_consistent) return false; - bool result = !get_context().inconsistent() && null_theory_var != mk_term(term); - CTRACE("utvpi", !result, tout << "Did not internalize " << mk_pp(term, get_manager()) << "\n";); + bool result = !ctx.inconsistent() && null_theory_var != mk_term(term); + CTRACE("utvpi", !result, tout << "Did not internalize " << mk_pp(term, m) << "\n";); return result; } @@ -378,8 +366,8 @@ namespace smt { void theory_utvpi::assign_eh(bool_var v, bool is_true) { m_stats.m_num_assertions++; unsigned idx = m_bool_var2atom.find(v); - SASSERT(get_context().get_assignment(v) != l_undef); - SASSERT((get_context().get_assignment(v) == l_true) == is_true); + SASSERT(ctx.get_assignment(v) != l_undef); + SASSERT((ctx.get_assignment(v) == l_true) == is_true); m_atoms[idx].assign_eh(is_true); m_asserted_atoms.push_back(idx); } @@ -471,7 +459,7 @@ namespace smt { m_nc_functor.reset(); VERIFY(m_graph.find_shortest_zero_edge_path(v1, v2, UINT_MAX, m_nc_functor)); VERIFY(m_graph.find_shortest_zero_edge_path(v2, v1, UINT_MAX, m_nc_functor)); - IF_VERBOSE(1, verbose_stream() << "parity conflict " << mk_pp(e->get_owner(), get_manager()) << "\n";); + IF_VERBOSE(1, verbose_stream() << "parity conflict " << mk_pp(e->get_owner(), m) << "\n";); set_conflict(); return false; @@ -510,7 +498,7 @@ namespace smt { template void theory_utvpi::propagate() { - bool consistent = is_consistent() && !get_context().inconsistent(); + bool consistent = is_consistent() && !ctx.inconsistent(); while (consistent && can_propagate()) { unsigned idx = m_asserted_atoms[m_asserted_qhead]; m_asserted_qhead++; @@ -532,8 +520,7 @@ namespace smt { template theory_var theory_utvpi::mk_term(app* n) { - TRACE("utvpi", tout << mk_pp(n, get_manager()) << "\n";); - context& ctx = get_context(); + TRACE("utvpi", tout << mk_pp(n, m) << "\n";); bool cl = m_test.linearize(n); if (!cl) { @@ -571,7 +558,6 @@ namespace smt { template theory_var theory_utvpi::mk_num(app* n, rational const& r) { theory_var v = null_theory_var; - context& ctx = get_context(); if (r.is_zero()) { v = get_zero(n); if (!ctx.e_internalized(n)) { @@ -602,7 +588,6 @@ namespace smt { template theory_var theory_utvpi::expand(bool pos, th_var v, rational & k) { - context& ctx = get_context(); enode* e = get_enode(v); expr* x, *y; rational r; @@ -831,7 +816,6 @@ namespace smt { template void theory_utvpi::model_validate() { - context& ctx = get_context(); for (auto const& a : m_atoms) { bool_var b = a.get_bool_var(); if (!ctx.is_relevant(b)) { @@ -853,13 +837,13 @@ namespace smt { CTRACE("utvpi", !ok, tout << "validation failed:\n"; tout << "Assignment: " << assign << "\n"; - tout << mk_pp(e, get_manager()) << "\n"; + tout << mk_pp(e, m) << "\n"; a.display(*this, tout); tout << "\n"; display(tout); m_graph.display_agl(tout); ); - // CTRACE("utvpi", ok, tout << "validation success: " << mk_pp(e, get_manager()) << "\n";); + // CTRACE("utvpi", ok, tout << "validation success: " << mk_pp(e, m) << "\n";); SASSERT(ok); } } @@ -873,10 +857,10 @@ namespace smt { if (a.is_lt(e, e1, e2) || a.is_gt(e, e2, e1)) { return eval_num(e1) < eval_num(e2); } - if (get_manager().is_eq(e, e1, e2)) { + if (m.is_eq(e, e1, e2)) { return eval_num(e1) == eval_num(e2); } - TRACE("utvpi", tout << "expression not handled: " << mk_pp(e, get_manager()) << "\n";); + TRACE("utvpi", tout << "expression not handled: " << mk_pp(e, m) << "\n";); return false; } @@ -909,7 +893,7 @@ namespace smt { if (is_uninterp_const(e)) { return mk_value(mk_var(e), a.is_int(e)); } - TRACE("utvpi", tout << "expression not handled: " << mk_pp(e, get_manager()) << "\n";); + TRACE("utvpi", tout << "expression not handled: " << mk_pp(e, m) << "\n";); UNREACHABLE(); return rational(0); } @@ -926,7 +910,7 @@ namespace smt { SASSERT(!is_int || num.is_int()); TRACE("utvpi", expr* n = get_enode(v)->get_owner(); - tout << mk_pp(n, get_manager()) << " |-> (" << val1 << " - " << val2 << ")/2 = " << num << "\n";); + tout << mk_pp(n, m) << " |-> (" << val1 << " - " << val2 << ")/2 = " << num << "\n";); return num; } @@ -936,7 +920,7 @@ namespace smt { theory_var v = n->get_th_var(get_id()); bool is_int = a.is_int(n->get_owner()); rational num = mk_value(v, is_int); - TRACE("utvpi", tout << mk_pp(n->get_owner(), get_manager()) << " |-> " << num << "\n";); + TRACE("utvpi", tout << mk_pp(n->get_owner(), m) << " |-> " << num << "\n";); return alloc(expr_wrapper_proc, m_factory->mk_num_value(num, is_int)); } @@ -980,7 +964,7 @@ namespace smt { template theory* theory_utvpi::mk_fresh(context* new_ctx) { - return alloc(theory_utvpi, new_ctx->get_manager()); + return alloc(theory_utvpi, *new_ctx); } diff --git a/src/smt/theory_wmaxsat.cpp b/src/smt/theory_wmaxsat.cpp index 4a293afd3..791d550a4 100644 --- a/src/smt/theory_wmaxsat.cpp +++ b/src/smt/theory_wmaxsat.cpp @@ -25,8 +25,8 @@ Notes: namespace smt { - theory_wmaxsat::theory_wmaxsat(ast_manager& m, generic_model_converter& mc): - theory(m.mk_family_id("weighted_maxsat")), + theory_wmaxsat::theory_wmaxsat(context& ctx, ast_manager& m, generic_model_converter& mc): + theory(ctx, m.mk_family_id("weighted_maxsat")), m_mc(mc), m_vars(m), m_fmls(m), @@ -88,7 +88,6 @@ namespace smt { } expr* theory_wmaxsat::assert_weighted(expr* fml, rational const& w) { - context & ctx = get_context(); ast_manager& m = get_manager(); app_ref var(m), wfml(m); var = m.mk_fresh_const("w", m.mk_bool_sort()); @@ -109,7 +108,6 @@ namespace smt { } void theory_wmaxsat::disable_var(expr* var) { - context& ctx = get_context(); SASSERT(ctx.b_internalized(var)); bool_var bv = ctx.get_bool_var(var); theory_var tv = m_bool2var[bv]; @@ -118,7 +116,6 @@ namespace smt { } bool_var theory_wmaxsat::register_var(app* var, bool attach) { - context & ctx = get_context(); bool_var bv; SASSERT(!ctx.e_internalized(var)); enode* x = ctx.mk_enode(var, false, true, true); @@ -159,7 +156,6 @@ namespace smt { void theory_wmaxsat::assign_eh(bool_var v, bool is_true) { if (is_true) { if (m_normalize) normalize(); - context& ctx = get_context(); theory_var tv = m_bool2var[v]; if (m_assigned[tv] || !m_enabled[tv]) return; scoped_mpz w(m_mpz); @@ -212,7 +208,6 @@ namespace smt { void theory_wmaxsat::propagate() { - context& ctx = get_context(); for (unsigned i = 0; m_propagate && i < m_vars.size(); ++i) { bool_var bv = m_var2bool[i]; lbool asgn = ctx.get_assignment(bv); @@ -256,7 +251,7 @@ namespace smt { tout << mk_pp(get_enode(m_costs[i])->get_owner(), get_manager()) << " "; } tout << "\n"; - //get_context().display(tout); + //ctx.display(tout); ); } expr_ref result(m.mk_or(disj.size(), disj.c_ptr()), m); @@ -273,7 +268,6 @@ namespace smt { return; } ++m_stats.m_num_blocks; - context& ctx = get_context(); literal_vector lits; compare_cost compare_cost(*this); svector costs(m_costs); @@ -293,7 +287,6 @@ namespace smt { } bool theory_wmaxsat::max_unassigned_is_blocked() { - context& ctx = get_context(); unsigned max_unassigned = m_max_unassigned_index; if (max_unassigned < m_sorted_vars.size() && m_zcost + m_zweights[m_sorted_vars[max_unassigned]] < m_zmin_cost) { @@ -322,7 +315,6 @@ namespace smt { void theory_wmaxsat::propagate(bool_var v) { ++m_stats.m_num_propagations; - context& ctx = get_context(); literal_vector lits; literal lit(v, true); diff --git a/src/smt/theory_wmaxsat.h b/src/smt/theory_wmaxsat.h index 2f146373c..f3d3b24a5 100644 --- a/src/smt/theory_wmaxsat.h +++ b/src/smt/theory_wmaxsat.h @@ -56,7 +56,7 @@ namespace smt { bool_vector m_assigned, m_enabled; stats m_stats; public: - theory_wmaxsat(ast_manager& m, generic_model_converter& mc); + theory_wmaxsat(context& ctx, ast_manager& m, generic_model_converter& mc); ~theory_wmaxsat() override; void get_assignment(bool_vector& result); expr* assert_weighted(expr* fml, rational const& w);