mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2026-06-05 00:20:50 +00:00
Code Activity

use expr based access to enodes to allow for storing first-class lambas

Browse source
This commit is contained in:
Nikolaj Bjorner 2026-05-30 15:12:56 -07:00
parent 5f3088f3b5
commit 2cc4422018
54 changed files with 301 additions and 279 deletions
Download patch file Download diff file Expand all files Collapse all files

4
src/ast/ast.h
View file

@ -1644,10 +1644,10 @@ public:
bool contains(ast * a) const { return m_ast_table.contains(a); } bool contains(ast * a) const { return m_ast_table.contains(a); }
bool is_lambda_def(quantifier* q) const { return q->get_qid() == m_lambda_def; } bool is_lambda_q(quantifier* q) const { return q->get_qid() == m_lambda_def; }
void add_lambda_def(func_decl* f, quantifier* q); void add_lambda_def(func_decl* f, quantifier* q);
quantifier* is_lambda_def(func_decl* f); quantifier* is_lambda_def(func_decl* f);
quantifier* is_lambda_def(app* e) { return is_lambda_def(e->get_decl()); } quantifier* is_lambda_def(expr* e) { return is_app(e) ? is_lambda_def(to_app(e)->get_decl()) : nullptr; }
obj_map<func_decl, quantifier*> const& lambda_defs() const { return m_lambda_defs; } obj_map<func_decl, quantifier*> const& lambda_defs() const { return m_lambda_defs; }
symbol const& lambda_def_qid() const { return m_lambda_def; } symbol const& lambda_def_qid() const { return m_lambda_def; }

4
src/ast/euf/ho_matcher.cpp
View file

@ -684,7 +684,7 @@ namespace euf {
} }
auto is_ho = any_of(subterms::all(expr_ref(p, m)), [&](expr* t) { auto is_ho = any_of(subterms::all(expr_ref(p, m)), [&](expr* t) {
return m_unitary.is_flex(0, t) || return m_unitary.is_flex(0, t) ||
(is_app(t) && m.is_lambda_def(to_app(t)->get_decl())) || m.is_lambda_def(t) ||
is_lambda(t); is_lambda(t);
}); });
if (!is_ho) if (!is_ho)
@ -702,7 +702,7 @@ namespace euf {
todo.pop_back(); todo.pop_back();
continue; continue;
} }
if (m_unitary.is_flex(0, t) || (is_app(t) && m.is_lambda_def(to_app(t)->get_decl())) || is_lambda(t)) { if (m_unitary.is_flex(0, t) || m.is_lambda_def(t) || is_lambda(t)) {
if (!contains_pat2abs) if (!contains_pat2abs)
m_pat2abs.insert_if_not_there(p, svector<std::pair<unsigned, expr*>>()).push_back({ nb, t }); m_pat2abs.insert_if_not_there(p, svector<std::pair<unsigned, expr*>>()).push_back({ nb, t });
auto v = m.mk_var(nb++, t->get_sort()); auto v = m.mk_var(nb++, t->get_sort());

2
src/ast/normal_forms/pull_quant.cpp
View file

@ -188,7 +188,7 @@ struct pull_quant::imp {
var_names.data(), var_names.data(),
nested_q->get_expr(), nested_q->get_expr(),
std::min(q->get_weight(), nested_q->get_weight()), std::min(q->get_weight(), nested_q->get_weight()),
m.is_lambda_def(q) ? symbol("pulled-lambda") : q->get_qid()); m.is_lambda_q(q) ? symbol("pulled-lambda") : q->get_qid());
} }
void pull_quant1(quantifier * q, expr * new_expr, expr_ref & result) { void pull_quant1(quantifier * q, expr * new_expr, expr_ref & result) {

6
src/smt/arith_eq_adapter.cpp
View file

@ -87,8 +87,8 @@ namespace smt {
tout << mk_ismt2_pp(n1->get_expr(), m) << "\n" << mk_ismt2_pp(n2->get_expr(), m) << "\n";); tout << mk_ismt2_pp(n1->get_expr(), m) << "\n" << mk_ismt2_pp(n2->get_expr(), m) << "\n";);
if (n1->get_owner_id() > n2->get_owner_id()) if (n1->get_owner_id() > n2->get_owner_id())
std::swap(n1, n2); std::swap(n1, n2);
app * t1 = n1->get_expr(); expr * t1 = n1->get_expr();
app * t2 = n2->get_expr(); expr * t2 = n2->get_expr();
if (m.are_distinct(t1, t2)) { if (m.are_distinct(t1, t2)) {
expr_ref eq(m.mk_eq(t1, t2), m); expr_ref eq(m.mk_eq(t1, t2), m);
ctx.internalize(eq, true); ctx.internalize(eq, true);
@ -233,7 +233,7 @@ namespace smt {
void arith_eq_adapter::new_eq_eh(theory_var v1, theory_var v2) { void arith_eq_adapter::new_eq_eh(theory_var v1, theory_var v2) {
TRACE(arith_eq_adapter, tout << "v" << v1 << " = v" << v2 << " #" << get_enode(v1)->get_owner_id() << " = #" << get_enode(v2)->get_owner_id() << "\n";); TRACE(arith_eq_adapter, tout << "v" << v1 << " = v" << v2 << " #" << get_enode(v1)->get_owner_id() << " = #" << get_enode(v2)->get_owner_id() << "\n";);
TRACE(arith_eq_adapter_bug, tout << mk_bounded_pp(get_enode(v1)->get_expr(), get_manager()) << "\n" << mk_bounded_pp(get_enode(v2)->get_expr(), get_manager()) << "\n";); TRACE(arith_eq_adapter_bug, tout << mk_bounded_pp(get_expr(v1), get_manager()) << "\n" << mk_bounded_pp(get_expr(v2), get_manager()) << "\n";);
mk_axioms(get_enode(v1), get_enode(v2)); mk_axioms(get_enode(v1), get_enode(v2));
} }

1
src/smt/arith_eq_adapter.h
View file

@ -70,6 +70,7 @@ namespace smt {
context & get_context() const { return m_owner.get_context(); } context & get_context() const { return m_owner.get_context(); }
ast_manager & get_manager() const { return m_owner.get_manager(); } ast_manager & get_manager() const { return m_owner.get_manager(); }
enode * get_enode(theory_var v) const { return m_owner.get_enode(v); } enode * get_enode(theory_var v) const { return m_owner.get_enode(v); }
expr * get_expr(theory_var v) const { return m_owner.get_expr(v); }
public: public:
arith_eq_adapter(theory & owner, arith_util & u):m_owner(owner), m_util(u) {} arith_eq_adapter(theory & owner, arith_util & u):m_owner(owner), m_util(u) {}

59
src/smt/dyn_ack.cpp
View file

@ -101,14 +101,14 @@ namespace smt {
}; };
class dyn_ack_eq_justification : public justification { class dyn_ack_eq_justification : public justification {
app * m_app1; expr * m_app1;
app * m_app2; expr * m_app2;
app * m_r; expr * m_r;
app * m_eq1; app * m_eq1;
app * m_eq2; app * m_eq2;
app * m_eq3; app * m_eq3;
public: public:
dyn_ack_eq_justification(app * n1, app * n2, app* r, app* eq1, app* eq2, app* eq3): dyn_ack_eq_justification(expr * n1, expr * n2, expr* r, app* eq1, app* eq2, app* eq3):
justification(false), // dyn_ack_cc_justifications are not stored in regions. justification(false), // dyn_ack_cc_justifications are not stored in regions.
m_app1(n1), m_app1(n1),
m_app2(n2), m_app2(n2),
@ -167,7 +167,7 @@ namespace smt {
dyn_ack_manager::~dyn_ack_manager() { dyn_ack_manager::~dyn_ack_manager() {
reset_app_pairs(); reset_app_pairs();
reset_app_triples(); reset_expr_triples();
} }
void dyn_ack_manager::reset_app_pairs() { void dyn_ack_manager::reset_app_pairs() {
@ -189,7 +189,7 @@ namespace smt {
m_num_propagations_since_last_gc = 0; m_num_propagations_since_last_gc = 0;
m_triple.m_app2num_occs.reset(); m_triple.m_app2num_occs.reset();
reset_app_triples(); reset_expr_triples();
m_triple.m_to_instantiate.reset(); m_triple.m_to_instantiate.reset();
m_triple.m_qhead = 0; m_triple.m_qhead = 0;
} }
@ -230,7 +230,7 @@ namespace smt {
} }
} }
void dyn_ack_manager::eq_eh(app * n1, app * n2, app* r) { void dyn_ack_manager::eq_eh(expr * n1, expr * n2, expr* r) {
if (n1 == n2 || r == n1 || r == n2 || m.is_bool(n1)) { if (n1 == n2 || r == n1 || r == n2 || m.is_bool(n1)) {
return; return;
} }
@ -238,7 +238,7 @@ namespace smt {
std::swap(n1,n2); std::swap(n1,n2);
TRACE(dyn_ack, TRACE(dyn_ack,
tout << mk_pp(n1, m) << " = " << mk_pp(n2, m) << " = " << mk_pp(r, m) << "\n";); tout << mk_pp(n1, m) << " = " << mk_pp(n2, m) << " = " << mk_pp(r, m) << "\n";);
app_triple tr(n1, n2, r); expr_triple tr(n1, n2, r);
if (m_triple.m_instantiated.contains(tr)) { if (m_triple.m_instantiated.contains(tr)) {
return; return;
} }
@ -361,7 +361,7 @@ namespace smt {
SASSERT(!m_app_pair2num_occs.contains(a1, a2)); SASSERT(!m_app_pair2num_occs.contains(a1, a2));
return; return;
} }
app_triple tr(0,0,0); expr_triple tr(0,0,0);
if (m_triple.m_clause2apps.find(cls, tr)) { if (m_triple.m_clause2apps.find(cls, tr)) {
[[maybe_unused]] auto [a1, a2, a3] = tr; [[maybe_unused]] auto [a1, a2, a3] = tr;
SASSERT(a1 && a2 && a3); SASSERT(a1 && a2 && a3);
@ -451,9 +451,8 @@ namespace smt {
m_triple.m_clause2apps.reset(); m_triple.m_clause2apps.reset();
} }
void dyn_ack_manager::reset_app_triples() { void dyn_ack_manager::reset_expr_triples() {
for (app_triple& p : m_triple.m_apps) { for (auto &[a1,a2,a3] : m_triple.m_apps) {
auto [a1, a2, a3] = p;
m.dec_ref(a1); m.dec_ref(a1);
m.dec_ref(a2); m.dec_ref(a2);
m.dec_ref(a3); m.dec_ref(a3);
@ -461,7 +460,7 @@ namespace smt {
m_triple.m_apps.reset(); m_triple.m_apps.reset();
} }
void dyn_ack_manager::instantiate(app * n1, app * n2, app* r) { void dyn_ack_manager::instantiate(expr * n1, expr * n2, expr* r) {
context& ctx = m_context; context& ctx = m_context;
SASSERT(m_params.m_dack != dyn_ack_strategy::DACK_DISABLED); SASSERT(m_params.m_dack != dyn_ack_strategy::DACK_DISABLED);
SASSERT(n1 != n2 && n1 != r && n2 != r); SASSERT(n1 != n2 && n1 != r && n2 != r);
@ -471,7 +470,7 @@ namespace smt {
<< mk_pp(n2, m) << "\n" << mk_pp(n2, m) << "\n"
<< mk_pp(r, m) << "\n"; << mk_pp(r, m) << "\n";
); );
app_triple tr(n1, n2, r); expr_triple tr(n1, n2, r);
SASSERT(m_triple.m_app2num_occs.contains(n1, n2, r)); SASSERT(m_triple.m_app2num_occs.contains(n1, n2, r));
m_triple.m_app2num_occs.erase(n1, n2, r); m_triple.m_app2num_occs.erase(n1, n2, r);
// pair n1,n2 is still in m_triple.m_apps // pair n1,n2 is still in m_triple.m_apps
@ -504,22 +503,22 @@ namespace smt {
} }
struct app_triple_lt { struct expr_triple_lt {
typedef triple<app *, app *, app*> app_triple; typedef triple<expr *, expr *,expr *> expr_triple;
typedef obj_triple_map<app, app, app, unsigned> app_triple2num_occs; typedef obj_triple_map<expr, expr, expr, unsigned> expr_triple2num_occs;
app_triple2num_occs & m_app_triple2num_occs; expr_triple2num_occs & m_expr_triple2num_occs;
app_triple_lt(app_triple2num_occs & m): expr_triple_lt(expr_triple2num_occs & m):
m_app_triple2num_occs(m) { m_expr_triple2num_occs(m) {
} }
bool operator()(app_triple const & p1, app_triple const & p2) const { bool operator()(expr_triple const & p1, expr_triple const & p2) const {
auto [a1_1, a1_2, a1_3] = p1; auto [a1_1, a1_2, a1_3] = p1;
auto [a2_1, a2_2, a2_3] = p2; auto [a2_1, a2_2, a2_3] = p2;
unsigned n1 = 0; unsigned n1 = 0;
unsigned n2 = 0; unsigned n2 = 0;
m_app_triple2num_occs.find(a1_1, a1_2, a1_3, n1); m_expr_triple2num_occs.find(a1_1, a1_2, a1_3, n1);
m_app_triple2num_occs.find(a2_1, a2_2, a2_3, n2); m_expr_triple2num_occs.find(a2_1, a2_2, a2_3, n2);
SASSERT(n1 > 0); SASSERT(n1 > 0);
SASSERT(n2 > 0); SASSERT(n2 > 0);
return n1 > n2; return n1 > n2;
@ -530,11 +529,11 @@ namespace smt {
TRACE(dyn_ack, tout << "dyn_ack GC\n";); TRACE(dyn_ack, tout << "dyn_ack GC\n";);
m_triple.m_to_instantiate.reset(); m_triple.m_to_instantiate.reset();
m_triple.m_qhead = 0; m_triple.m_qhead = 0;
svector<app_triple>::iterator it = m_triple.m_apps.begin(); svector<expr_triple>::iterator it = m_triple.m_apps.begin();
svector<app_triple>::iterator end = m_triple.m_apps.end(); svector<expr_triple>::iterator end = m_triple.m_apps.end();
svector<app_triple>::iterator it2 = it; svector<expr_triple>::iterator it2 = it;
for (; it != end; ++it) { for (; it != end; ++it) {
app_triple & p = *it; expr_triple & p = *it;
auto [a1, a2, a3] = p; auto [a1, a2, a3] = p;
if (m_triple.m_instantiated.contains(p)) { if (m_triple.m_instantiated.contains(p)) {
TRACE(dyn_ack, tout << "1) erasing:\n" << mk_pp(a1, m) << "\n" << mk_pp(a2, m) << "\n";); TRACE(dyn_ack, tout << "1) erasing:\n" << mk_pp(a1, m) << "\n" << mk_pp(a2, m) << "\n";);
@ -548,7 +547,7 @@ namespace smt {
m_triple.m_app2num_occs.find(a1, a2, a3, num_occs); m_triple.m_app2num_occs.find(a1, a2, a3, num_occs);
// The following invariant is not true. a1 and // The following invariant is not true. a1 and
// a2 may have been instantiated, and removed from // a2 may have been instantiated, and removed from
// m_app_triple2num_occs, but not from m_app_triples. // m_triple.m_app2num_occs, but not from m_triple.m_apps.
// //
// SASSERT(num_occs > 0); // SASSERT(num_occs > 0);
num_occs = static_cast<unsigned>(num_occs * m_params.m_dack_gc_inv_decay); num_occs = static_cast<unsigned>(num_occs * m_params.m_dack_gc_inv_decay);
@ -568,8 +567,8 @@ namespace smt {
m_triple.m_to_instantiate.push_back(p); m_triple.m_to_instantiate.push_back(p);
} }
m_triple.m_apps.set_end(it2); m_triple.m_apps.set_end(it2);
app_triple_lt f(m_triple.m_app2num_occs); expr_triple_lt f(m_triple.m_app2num_occs);
// app_triple_lt is not a total order // expr_triple_lt is not a total order
std::stable_sort(m_triple.m_to_instantiate.begin(), m_triple.m_to_instantiate.end(), f); std::stable_sort(m_triple.m_to_instantiate.begin(), m_triple.m_to_instantiate.end(), f);
} }

28
src/smt/dyn_ack.h
View file

@ -36,11 +36,11 @@ namespace smt {
typedef obj_pair_hashtable<app, app> app_pair_set; typedef obj_pair_hashtable<app, app> app_pair_set;
typedef obj_map<clause, app_pair> clause2app_pair; typedef obj_map<clause, app_pair> clause2app_pair;
typedef triple<app *, app *,app *> app_triple; typedef triple<expr *, expr *,expr *> expr_triple;
typedef obj_triple_map<app, app, app, unsigned> app_triple2num_occs; typedef obj_triple_map<expr, expr, expr, unsigned> expr_triple2num_occs;
typedef svector<app_triple> app_triple_vector; typedef svector<expr_triple> expr_triple_vector;
typedef obj_triple_hashtable<app, app, app> app_triple_set; typedef obj_triple_hashtable<expr, expr, expr> expr_triple_set;
typedef obj_map<clause, app_triple> clause2app_triple; typedef obj_map<clause, expr_triple> clause2expr_triple;
context & m_context; context & m_context;
ast_manager & m; ast_manager & m;
@ -55,14 +55,14 @@ namespace smt {
clause2app_pair m_clause2app_pair; clause2app_pair m_clause2app_pair;
struct _triple { struct _triple {
app_triple2num_occs m_app2num_occs; expr_triple2num_occs m_app2num_occs;
app_triple_vector m_apps; expr_triple_vector m_apps;
app_triple_vector m_to_instantiate; expr_triple_vector m_to_instantiate;
unsigned m_qhead; unsigned m_qhead;
unsigned m_num_instances; unsigned m_num_instances;
unsigned m_num_propagations_since_last_gc; unsigned m_num_propagations_since_last_gc;
app_triple_set m_instantiated; expr_triple_set m_instantiated;
clause2app_triple m_clause2apps; clause2expr_triple m_clause2apps;
}; };
_triple m_triple; _triple m_triple;
@ -76,9 +76,9 @@ namespace smt {
literal mk_eq(expr * n1, expr * n2); literal mk_eq(expr * n1, expr * n2);
void cg_eh(app * n1, app * n2); void cg_eh(app * n1, app * n2);
void eq_eh(app * n1, app * n2, app* r); void eq_eh(expr * n1, expr * n2, expr* r);
void instantiate(app * n1, app * n2, app* r); void instantiate(expr * n1, expr * n2, expr* r);
void reset_app_triples(); void reset_expr_triples();
void gc_triples(); void gc_triples();
public: public:
@ -112,7 +112,7 @@ namespace smt {
/** /**
\brief This method is invoked when equalities are used during conflict resolution. \brief This method is invoked when equalities are used during conflict resolution.
*/ */
void used_eq_eh(app * n1, app * n2, app* r) { void used_eq_eh(expr * n1, expr * n2, expr* r) {
if (m_params.m_dack_eq) if (m_params.m_dack_eq)
eq_eh(n1, n2, r); eq_eh(n1, n2, r);
} }

2
src/smt/qi_queue.cpp
View file

@ -140,7 +140,7 @@ namespace smt {
tout << "new instance of " << q->get_qid() << ", weight " << q->get_weight() tout << "new instance of " << q->get_qid() << ", weight " << q->get_weight()
<< ", generation: " << generation << ", scope_level: " << m_context.get_scope_level() << ", cost: " << cost << "\n"; << ", generation: " << generation << ", scope_level: " << m_context.get_scope_level() << ", cost: " << cost << "\n";
for (unsigned i = 0; i < f->get_num_args(); ++i) { for (unsigned i = 0; i < f->get_num_args(); ++i) {
tout << "#" << f->get_arg(i)->get_expr_id() << " d:" << f->get_arg(i)->get_expr()->get_depth() << " "; tout << "#" << f->get_arg(i)->get_expr_id() << " d:" << get_depth(f->get_arg(i)->get_expr()) << " ";
} }
tout << "\n";); tout << "\n";);
TRACE(new_entries_bug, tout << "[qi:insert]\n";); TRACE(new_entries_bug, tout << "[qi:insert]\n";);

2
src/smt/smt_almost_cg_table.cpp
View file

@ -77,7 +77,7 @@ namespace smt {
} }
bool almost_cg_table::cg_eq::operator()(enode * n1, enode * n2) const { bool almost_cg_table::cg_eq::operator()(enode * n1, enode * n2) const {
if (n1->get_expr()->get_decl() != n2->get_expr()->get_decl()) if (n1->get_decl() != n2->get_decl() || !n1->is_app())
return false; return false;
unsigned num_args = n1->get_num_args(); unsigned num_args = n1->get_num_args();
if (num_args != n2->get_num_args()) if (num_args != n2->get_num_args())

14
src/smt/smt_conflict_resolution.cpp
View file

@ -126,7 +126,7 @@ namespace smt {
break; break;
case eq_justification::CONGRUENCE: { case eq_justification::CONGRUENCE: {
CTRACE(dyn_ack_target, !lhs->is_eq(), tout << "dyn_ack_target2: " << lhs->get_owner_id() << " " << rhs->get_owner_id() << "\n";); CTRACE(dyn_ack_target, !lhs->is_eq(), tout << "dyn_ack_target2: " << lhs->get_owner_id() << " " << rhs->get_owner_id() << "\n";);
m_dyn_ack_manager.used_cg_eh(lhs->get_expr(), rhs->get_expr()); m_dyn_ack_manager.used_cg_eh(lhs->get_app(), rhs->get_app());
unsigned num_args = lhs->get_num_args(); unsigned num_args = lhs->get_num_args();
SASSERT(num_args == rhs->get_num_args()); SASSERT(num_args == rhs->get_num_args());
if (js.used_commutativity()) { if (js.used_commutativity()) {
@ -787,8 +787,8 @@ namespace smt {
SASSERT(m.has_fact(pr)); SASSERT(m.has_fact(pr));
expr* f1 = nullptr, *f2 = nullptr; expr* f1 = nullptr, *f2 = nullptr;
app * fact = to_app(m.get_fact(pr)); app * fact = to_app(m.get_fact(pr));
app * n1_owner = n1->get_expr(); expr * n1_owner = n1->get_expr();
app * n2_owner = n2->get_expr(); expr * n2_owner = n2->get_expr();
bool is_eq = m.is_eq(fact, f1, f2); bool is_eq = m.is_eq(fact, f1, f2);
if (is_eq && is_quantifier(f1)) { if (is_eq && is_quantifier(f1)) {
f1 = m_ctx.get_enode(f1)->get_expr(); f1 = m_ctx.get_enode(f1)->get_expr();
@ -855,7 +855,7 @@ namespace smt {
case eq_justification::CONGRUENCE: case eq_justification::CONGRUENCE:
num_args = n1->get_num_args(); num_args = n1->get_num_args();
SASSERT(num_args == n2->get_num_args()); SASSERT(num_args == n2->get_num_args());
SASSERT(n1->get_expr()->get_decl() == n2->get_expr()->get_decl()); SASSERT(n1->get_app()->get_decl() == n2->get_app()->get_decl());
if (js.used_commutativity()) { if (js.used_commutativity()) {
bool visited = true; bool visited = true;
SASSERT(num_args == 2); SASSERT(num_args == 2);
@ -878,8 +878,8 @@ namespace smt {
} }
if (!visited) if (!visited)
return nullptr; return nullptr;
app * e1 = n1->get_expr(); app * e1 = n1->get_app();
app * e2 = n2->get_expr(); app * e2 = n2->get_app();
app * e2_prime = m.mk_app(e2->get_decl(), e2->get_arg(1), e2->get_arg(0)); app * e2_prime = m.mk_app(e2->get_decl(), e2->get_arg(1), e2->get_arg(0));
proof * pr1 = nullptr; proof * pr1 = nullptr;
if (!prs.empty()) { if (!prs.empty()) {
@ -910,7 +910,7 @@ namespace smt {
} }
if (!visited) if (!visited)
return nullptr; return nullptr;
proof * pr = m.mk_congruence(n1->get_expr(), n2->get_expr(), prs.size(), prs.data()); proof * pr = m.mk_congruence(n1->get_app(), n2->get_app(), prs.size(), prs.data());
m_new_proofs.push_back(pr); m_new_proofs.push_back(pr);
return pr; return pr;
} }

16
src/smt/smt_context.cpp
View file

@ -216,7 +216,7 @@ namespace smt {
} }
ast_translation tr(src_ctx.m, m, false); ast_translation tr(src_ctx.m, m, false);
for (unsigned i = 0; i < src_ctx.m_user_propagator->get_num_vars(); ++i) { for (unsigned i = 0; i < src_ctx.m_user_propagator->get_num_vars(); ++i) {
app* e = src_ctx.m_user_propagator->get_expr(i); auto e = src_ctx.m_user_propagator->get_expr(i);
m_user_propagator->add_expr(tr(e), true); m_user_propagator->add_expr(tr(e), true);
} }
} }
@ -653,7 +653,7 @@ namespace smt {
lbool val = get_assignment(v); lbool val = get_assignment(v);
if (val != l_true) { if (val != l_true) {
if (val == l_false && js.get_kind() == eq_justification::CONGRUENCE) if (val == l_false && js.get_kind() == eq_justification::CONGRUENCE)
m_dyn_ack_manager.cg_conflict_eh(n1->get_expr(), n2->get_expr()); m_dyn_ack_manager.cg_conflict_eh(n1->get_app(), n2->get_app());
assign(literal(v), mk_justification(eq_propagation_justification(lhs, rhs))); assign(literal(v), mk_justification(eq_propagation_justification(lhs, rhs)));
} }
// It is not necessary to reinsert the equality to the congruence table // It is not necessary to reinsert the equality to the congruence table
@ -919,7 +919,7 @@ namespace smt {
lbool val2 = get_assignment(v2); lbool val2 = get_assignment(v2);
if (val2 != val) { if (val2 != val) {
if (val2 != l_undef && congruent(source, target) && source->get_num_args() > 0) if (val2 != l_undef && congruent(source, target) && source->get_num_args() > 0)
m_dyn_ack_manager.cg_conflict_eh(source->get_expr(), target->get_expr()); m_dyn_ack_manager.cg_conflict_eh(source->get_app(), target->get_app());
assign(literal(v2, sign), mk_justification(mp_iff_justification(source, target))); assign(literal(v2, sign), mk_justification(mp_iff_justification(source, target)));
} }
target = target->get_next(); target = target->get_next();
@ -1137,7 +1137,7 @@ namespace smt {
m.inc_ref(eq); m.inc_ref(eq);
_this->m_is_diseq_tmp = enode::mk_dummy(m, m_app2enode, eq); _this->m_is_diseq_tmp = enode::mk_dummy(m, m_app2enode, eq);
} }
else if (m_is_diseq_tmp->get_expr()->get_arg(0)->get_sort() != n1->get_sort()) { else if (m_is_diseq_tmp->get_arg(0)->get_sort() != n1->get_sort()) {
m.dec_ref(m_is_diseq_tmp->get_expr()); m.dec_ref(m_is_diseq_tmp->get_expr());
app * eq = m.mk_eq(n1->get_expr(), n2->get_expr()); app * eq = m.mk_eq(n1->get_expr(), n2->get_expr());
m.inc_ref(eq); m.inc_ref(eq);
@ -1284,14 +1284,14 @@ namespace smt {
enode * r = m_cg_table.find(tmp); enode * r = m_cg_table.find(tmp);
#ifdef Z3DEBUG #ifdef Z3DEBUG
if (r != nullptr) { if (r != nullptr) {
SASSERT(r->get_expr()->get_decl() == f); SASSERT(r->get_decl() == f);
SASSERT(r->get_num_args() == num_args); SASSERT(r->get_num_args() == num_args);
if (r->is_commutative()) { if (r->is_commutative()) {
// TODO // TODO
} }
else { else {
for (unsigned i = 0; i < num_args; ++i) { for (unsigned i = 0; i < num_args; ++i) {
expr * arg = r->get_expr()->get_arg(i); expr * arg = r->get_arg(i)->get_expr();
SASSERT(e_internalized(arg)); SASSERT(e_internalized(arg));
enode * _arg = get_enode(arg); enode * _arg = get_enode(arg);
CTRACE(eq_to_bug, args[i]->get_root() != _arg->get_root(), CTRACE(eq_to_bug, args[i]->get_root() != _arg->get_root(),
@ -4672,7 +4672,7 @@ namespace smt {
theory_id th_id = l->get_id(); theory_id th_id = l->get_id();
for (enode * parent : enode::parents(n)) { for (enode * parent : enode::parents(n)) {
app* p = parent->get_expr(); auto p = parent->get_app();
family_id fid = p->get_family_id(); family_id fid = p->get_family_id();
if (fid != th_id && fid != m.get_basic_family_id()) { if (fid != th_id && fid != m.get_basic_family_id()) {
if (is_beta_redex(parent, n)) if (is_beta_redex(parent, n))
@ -4721,7 +4721,7 @@ namespace smt {
} }
bool context::is_beta_redex(enode* p, enode* n) const { bool context::is_beta_redex(enode* p, enode* n) const {
family_id th_id = p->get_expr()->get_family_id(); family_id th_id = p->get_family_id();
theory * th = get_theory(th_id); theory * th = get_theory(th_id);
return th && th->is_beta_redex(p, n); return th && th->is_beta_redex(p, n);
} }

2
src/smt/smt_context.h
View file

@ -1154,7 +1154,7 @@ namespace smt {
void push_eq(enode * lhs, enode * rhs, eq_justification const & js) { void push_eq(enode * lhs, enode * rhs, eq_justification const & js) {
if (lhs->get_root() != rhs->get_root()) { if (lhs->get_root() != rhs->get_root()) {
SASSERT(lhs->get_expr()->get_sort() == rhs->get_expr()->get_sort()); SASSERT(lhs->get_sort() == rhs->get_sort());
m_eq_propagation_queue.push_back(new_eq(lhs, rhs, js)); m_eq_propagation_queue.push_back(new_eq(lhs, rhs, js));
} }
} }

4
src/smt/smt_context_pp.cpp
View file

@ -545,14 +545,14 @@ namespace smt {
out << std::left << n->get_owner_id() << " #"; out << std::left << n->get_owner_id() << " #";
out.width(5); out.width(5);
out << n->get_root()->get_owner_id() << " := " << std::right; out << n->get_root()->get_owner_id() << " := " << std::right;
unsigned num = n->get_expr()->get_num_args(); unsigned num = n->get_num_args();
if (num > 0) if (num > 0)
out << "("; out << "(";
out << n->get_decl()->get_name(); out << n->get_decl()->get_name();
if (!n->get_decl()->private_parameters()) if (!n->get_decl()->private_parameters())
display_parameters(out, n->get_decl()->get_num_parameters(), n->get_decl()->get_parameters()); display_parameters(out, n->get_decl()->get_num_parameters(), n->get_decl()->get_parameters());
for (unsigned i = 0; i < num; ++i) { for (unsigned i = 0; i < num; ++i) {
expr * arg = n->get_expr()->get_arg(i); expr * arg = n->get_arg(i)->get_expr();
if (e_internalized(arg)) { if (e_internalized(arg)) {
enode * n = get_enode(arg)->get_root(); enode * n = get_enode(arg)->get_root();
out << " #" << n->get_owner_id(); out << " #" << n->get_owner_id();

2
src/smt/smt_enode.cpp
View file

@ -280,7 +280,7 @@ namespace smt {
bool congruent(enode * n1, enode * n2, bool & comm) { bool congruent(enode * n1, enode * n2, bool & comm) {
comm = false; comm = false;
if (n1->get_expr()->get_decl() != n2->get_expr()->get_decl()) if (!n1->is_app() || n1->get_decl() != n2->get_decl())
return false; return false;
unsigned num_args = n1->get_num_args(); unsigned num_args = n1->get_num_args();
if (num_args != n2->get_num_args()) if (num_args != n2->get_num_args())

14
src/smt/smt_enode.h
View file

@ -166,7 +166,15 @@ namespace smt {
void del_eh(ast_manager & m, bool update_children_parent = true); void del_eh(ast_manager & m, bool update_children_parent = true);
app * get_expr() const { return m_owner; } app * get_app() const { return m_owner; }
expr *get_expr() const {
return m_owner;
}
bool is_app() const {
return ::is_app(m_owner);
}
unsigned get_owner_id() const { return m_owner->get_id(); } unsigned get_owner_id() const { return m_owner->get_id(); }
unsigned get_expr_id() const { return m_owner->get_id(); } unsigned get_expr_id() const { return m_owner->get_id(); }
@ -176,6 +184,10 @@ namespace smt {
sort* get_sort() const { return m_owner->get_sort(); } sort* get_sort() const { return m_owner->get_sort(); }
family_id get_family_id() const {
return m_owner->get_family_id();
}
unsigned hash() const { unsigned hash() const {
return m_owner->hash(); return m_owner->hash();
} }

4
src/smt/smt_model_checker.cpp
View file

@ -459,7 +459,7 @@ namespace smt {
tout << "model:\n"; model_pp(tout, *m_curr_model);); tout << "model:\n"; model_pp(tout, *m_curr_model););
for (quantifier* q : *m_qm) for (quantifier* q : *m_qm)
if (m.is_lambda_def(q)) { if (m.is_lambda_q(q)) {
md->add_lambda_defs(); md->add_lambda_defs();
break; break;
} }
@ -519,7 +519,7 @@ namespace smt {
if (!(m_qm->mbqi_enabled(q) && if (!(m_qm->mbqi_enabled(q) &&
m_context->is_relevant(q) && m_context->is_relevant(q) &&
m_context->get_assignment(q) == l_true && m_context->get_assignment(q) == l_true &&
(!m_context->get_fparams().m_ematching || !m.is_lambda_def(q)))) { (!m_context->get_fparams().m_ematching || !m.is_lambda_q(q)))) {
if (!m_qm->mbqi_enabled(q)) if (!m_qm->mbqi_enabled(q))
++num_failures; ++num_failures;
continue; continue;

14
src/smt/smt_model_finder.cpp
View file

@ -1396,7 +1396,7 @@ namespace smt {
enode_vector::iterator end2 = curr->end_parents(); enode_vector::iterator end2 = curr->end_parents();
for (; it2 != end2; ++it2) { for (; it2 != end2; ++it2) {
enode* p = *it2; enode* p = *it2;
if (ctx->is_relevant(p) && p->get_expr()->get_decl() == auf_arr->get_decl()) { if (ctx->is_relevant(p) && p->get_decl() == auf_arr->get_decl()) {
arrays.push_back(p); arrays.push_back(p);
} }
} }
@ -1449,7 +1449,7 @@ namespace smt {
}); });
node* n1 = s.get_uvar(q, m_var_j); node* n1 = s.get_uvar(q, m_var_j);
for (enode* n : arrays) { for (enode* n : arrays) {
app* ground_array = n->get_expr(); auto ground_array = n->get_app();
func_decl* f = get_array_func_decl(ground_array, s); func_decl* f = get_array_func_decl(ground_array, s);
if (f) { if (f) {
SASSERT(m_arg_i >= 1); SASSERT(m_arg_i >= 1);
@ -1463,7 +1463,7 @@ namespace smt {
ptr_buffer<enode> arrays; ptr_buffer<enode> arrays;
get_auf_arrays(get_array(), ctx, arrays); get_auf_arrays(get_array(), ctx, arrays);
for (enode* curr : arrays) { for (enode* curr : arrays) {
app* ground_array = curr->get_expr(); auto ground_array = curr->get_app();
func_decl* f = get_array_func_decl(ground_array, s); func_decl* f = get_array_func_decl(ground_array, s);
if (f) { if (f) {
node* A_f_i = s.get_A_f_i(f, m_arg_i - 1); node* A_f_i = s.get_A_f_i(f, m_arg_i - 1);
@ -1471,8 +1471,8 @@ namespace smt {
enode_vector::iterator end2 = curr->end_parents(); enode_vector::iterator end2 = curr->end_parents();
for (; it2 != end2; ++it2) { for (; it2 != end2; ++it2) {
enode* p = *it2; enode* p = *it2;
if (ctx->is_relevant(p) && p->get_expr()->get_decl() == m_select->get_decl()) { if (ctx->is_relevant(p) && p->get_decl() == m_select->get_decl()) {
SASSERT(m_arg_i < p->get_expr()->get_num_args()); SASSERT(m_arg_i < p->get_num_args());
enode* e_arg = p->get_arg(m_arg_i); enode* e_arg = p->get_arg(m_arg_i);
A_f_i->insert(e_arg->get_expr(), e_arg->get_generation()); A_f_i->insert(e_arg->get_expr(), e_arg->get_generation());
} }
@ -1690,7 +1690,7 @@ namespace smt {
typedef ptr_vector<cond_macro>::const_iterator macro_iterator; typedef ptr_vector<cond_macro>::const_iterator macro_iterator;
static quantifier_ref mk_flat(ast_manager& m, quantifier* q) { static quantifier_ref mk_flat(ast_manager& m, quantifier* q) {
if (has_quantifiers(q->get_expr()) && !m.is_lambda_def(q)) { if (has_quantifiers(q->get_expr()) && !m.is_lambda_q(q)) {
proof_ref pr(m); proof_ref pr(m);
expr_ref new_q(m); expr_ref new_q(m);
pull_quant pull(m); pull_quant pull(m);
@ -2279,7 +2279,7 @@ namespace smt {
void operator()(quantifier_info* d) { void operator()(quantifier_info* d) {
m_info = d; m_info = d;
quantifier* q = d->get_flat_q(); quantifier* q = d->get_flat_q();
if (m.is_lambda_def(q)) return; if (m.is_lambda_q(q)) return;
expr* e = q->get_expr(); expr* e = q->get_expr();
reset_cache(); reset_cache();
if (!m.inc()) return; if (!m.inc()) return;

4
src/smt/smt_model_generator.cpp
View file

@ -105,7 +105,7 @@ namespace smt {
proc = alloc(expr_wrapper_proc, m.mk_false()); proc = alloc(expr_wrapper_proc, m.mk_false());
} }
else if (m.is_model_value(r->get_expr())) else if (m.is_model_value(r->get_expr()))
proc = alloc(expr_wrapper_proc, r->get_expr()); proc = alloc(expr_wrapper_proc, r->get_app());
else { else {
family_id fid = s->get_family_id(); family_id fid = s->get_family_id();
theory * th = m_context->get_theory(fid); theory * th = m_context->get_theory(fid);
@ -384,7 +384,7 @@ namespace smt {
// send model // send model
for (enode * n : m_context->enodes()) { for (enode * n : m_context->enodes()) {
if (is_uninterp_const(n->get_expr()) && m_context->is_relevant(n)) { if (is_uninterp_const(n->get_expr()) && m_context->is_relevant(n)) {
func_decl * d = n->get_expr()->get_decl(); func_decl * d = n->get_decl();
TRACE(mg_top_sort, tout << d->get_name() << " " << (m_hidden_ufs.contains(d)?"hidden":"visible") << "\n";); TRACE(mg_top_sort, tout << d->get_name() << " " << (m_hidden_ufs.contains(d)?"hidden":"visible") << "\n";);
if (m_hidden_ufs.contains(d)) continue; if (m_hidden_ufs.contains(d)) continue;
expr * val = get_value(n); expr * val = get_value(n);

4
src/smt/smt_theory.h
View file

@ -259,7 +259,7 @@ namespace smt {
\brief This method is invoked when the theory application n \brief This method is invoked when the theory application n
is marked as relevant. is marked as relevant.
*/ */
virtual void relevant_eh(app * n) { virtual void relevant_eh(expr * n) {
} }
/** /**
@ -435,7 +435,7 @@ namespace smt {
return m_var2enode[v]; return m_var2enode[v];
} }
app * get_expr(theory_var v) const { expr * get_expr(theory_var v) const {
return get_enode(v)->get_expr(); return get_enode(v)->get_expr();
} }

6
src/smt/theory_arith.h
View file

@ -524,7 +524,7 @@ namespace smt {
bool has_var(expr * v) const { return get_context().e_internalized(v) && get_context().get_enode(v)->get_th_var(get_id()) != null_theory_var; } bool has_var(expr * v) const { return get_context().e_internalized(v) && get_context().get_enode(v)->get_th_var(get_id()) != null_theory_var; }
theory_var expr2var(expr * v) const { SASSERT(get_context().e_internalized(v)); return get_context().get_enode(v)->get_th_var(get_id()); } theory_var expr2var(expr * v) const { SASSERT(get_context().e_internalized(v)); return get_context().get_enode(v)->get_th_var(get_id()); }
expr * var2expr(theory_var v) const { return get_enode(v)->get_expr(); } expr * var2expr(theory_var v) const { return get_expr(v); }
bool reflection_enabled() const; bool reflection_enabled() const;
bool reflect(app * n) const; bool reflect(app * n) const;
unsigned lazy_pivoting_lvl() const { return m_params.m_arith_lazy_pivoting_lvl; } unsigned lazy_pivoting_lvl() const { return m_params.m_arith_lazy_pivoting_lvl; }
@ -656,7 +656,7 @@ namespace smt {
void push_scope_eh() override; void push_scope_eh() override;
void pop_scope_eh(unsigned num_scopes) override; void pop_scope_eh(unsigned num_scopes) override;
void relevant_eh(app * n) override; void relevant_eh(expr * n) override;
void restart_eh() override; void restart_eh() override;
void init_search_eh() override; void init_search_eh() override;
@ -966,7 +966,7 @@ namespace smt {
\brief A monomial is 'pure' if does not have a numeric coefficient. \brief A monomial is 'pure' if does not have a numeric coefficient.
*/ */
bool is_pure_monomial(expr * m) const; bool is_pure_monomial(expr * m) const;
bool is_pure_monomial(theory_var v) const { return is_pure_monomial(get_enode(v)->get_expr()); } bool is_pure_monomial(theory_var v) const { return is_pure_monomial(get_expr(v)); }
void mark_var(theory_var v, svector<theory_var> & vars, var_set & already_found); void mark_var(theory_var v, svector<theory_var> & vars, var_set & already_found);
void mark_dependents(theory_var v, svector<theory_var> & vars, var_set & already_found, row_set & already_visited_rows); void mark_dependents(theory_var v, svector<theory_var> & vars, var_set & already_found, row_set & already_visited_rows);
void get_non_linear_cluster(svector<theory_var> & vars); void get_non_linear_cluster(svector<theory_var> & vars);

10
src/smt/theory_arith_aux.h
View file

@ -1086,7 +1086,7 @@ namespace smt {
expr_ref theory_arith<Ext>::mk_gt(theory_var v) { expr_ref theory_arith<Ext>::mk_gt(theory_var v) {
ast_manager& m = get_manager(); ast_manager& m = get_manager();
inf_numeral const& val = get_value(v); inf_numeral const& val = get_value(v);
expr* obj = get_enode(v)->get_expr(); expr* obj = get_expr(v);
expr_ref e(m); expr_ref e(m);
rational r = val.get_rational(); rational r = val.get_rational();
if (m_util.is_int(obj->get_sort())) { if (m_util.is_int(obj->get_sort())) {
@ -1124,7 +1124,7 @@ namespace smt {
expr_ref theory_arith<Ext>::mk_ge(generic_model_converter& fm, theory_var v, inf_numeral const& val) { expr_ref theory_arith<Ext>::mk_ge(generic_model_converter& fm, theory_var v, inf_numeral const& val) {
ast_manager& m = get_manager(); ast_manager& m = get_manager();
std::ostringstream strm; std::ostringstream strm;
strm << val << " <= " << mk_pp(get_enode(v)->get_expr(), get_manager()); strm << val << " <= " << mk_pp(get_expr(v), get_manager());
app* b = m.mk_const(symbol(strm.str()), m.mk_bool_sort()); app* b = m.mk_const(symbol(strm.str()), m.mk_bool_sort());
expr_ref result(b, m); expr_ref result(b, m);
TRACE(opt, tout << result << "\n";); TRACE(opt, tout << result << "\n";);
@ -1799,7 +1799,7 @@ namespace smt {
*/ */
template<typename Ext> template<typename Ext>
typename theory_arith<Ext>::max_min_t theory_arith<Ext>::max_min(theory_var v, bool max, bool maintain_integrality, bool& has_shared) { typename theory_arith<Ext>::max_min_t theory_arith<Ext>::max_min(theory_var v, bool max, bool maintain_integrality, bool& has_shared) {
expr* e = get_enode(v)->get_expr(); expr* e = get_expr(v);
(void)e; (void)e;
SASSERT(!maintain_integrality || valid_assignment()); SASSERT(!maintain_integrality || valid_assignment());
SASSERT(satisfy_bounds()); SASSERT(satisfy_bounds());
@ -2179,8 +2179,8 @@ namespace smt {
TRACE(shared, tout << ctx.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) { for (; it != end; ++it) {
enode * parent = *it; enode * parent = *it;
app * o = parent->get_expr(); app * o = parent->get_app();
if (o->get_family_id() == get_id()) { if (parent->get_family_id() == get_id()) {
switch (o->get_decl_kind()) { switch (o->get_decl_kind()) {
case OP_DIV: case OP_DIV:
case OP_IDIV: case OP_IDIV:

23
src/smt/theory_arith_core.h
View file

@ -1381,18 +1381,19 @@ namespace smt {
} }
template<typename Ext> template<typename Ext>
void theory_arith<Ext>::relevant_eh(app * n) { void theory_arith<Ext>::relevant_eh(expr * n) {
TRACE(arith_relevant_eh, tout << "relevant_eh: " << mk_pp(n, m) << "\n";); TRACE(arith_relevant_eh, tout << "relevant_eh: " << mk_pp(n, m) << "\n";);
if (m_util.is_mod(n)) expr* x = nullptr, *y = nullptr;
mk_idiv_mod_axioms(n->get_arg(0), n->get_arg(1)); if (m_util.is_mod(n, x, y))
else if (m_util.is_rem(n)) mk_idiv_mod_axioms(x, y);
mk_rem_axiom(n->get_arg(0), n->get_arg(1)); else if (m_util.is_rem(n, x, y))
else if (m_util.is_div(n)) mk_rem_axiom(x, y);
mk_div_axiom(n->get_arg(0), n->get_arg(1)); else if (m_util.is_div(n, x, y))
mk_div_axiom(x, y);
else if (m_util.is_to_int(n)) else if (m_util.is_to_int(n))
mk_to_int_axiom(n); mk_to_int_axiom(to_app(n));
else if (m_util.is_is_int(n)) else if (m_util.is_is_int(n))
mk_is_int_axiom(n); mk_is_int_axiom(to_app(n));
} }
template<typename Ext> template<typename Ext>
@ -1451,8 +1452,8 @@ namespace smt {
template<typename Ext> template<typename Ext>
void theory_arith<Ext>::new_diseq_eh(theory_var v1, theory_var v2) { void theory_arith<Ext>::new_diseq_eh(theory_var v1, theory_var v2) {
TRACE(arith_new_diseq_eh, tout << mk_bounded_pp(get_enode(v1)->get_expr(), m) << "\n" << TRACE(arith_new_diseq_eh, tout << mk_bounded_pp(get_expr(v1), m) << "\n" <<
mk_bounded_pp(get_enode(v2)->get_expr(), m) << "\n";); mk_bounded_pp(get_expr(v2), m) << "\n";);
m_stats.m_assert_diseq++; m_stats.m_assert_diseq++;
m_arith_eq_adapter.new_diseq_eh(v1, v2); m_arith_eq_adapter.new_diseq_eh(v1, v2);
} }

8
src/smt/theory_arith_int.h
View file

@ -215,7 +215,7 @@ namespace smt {
tout << "k = " << k << ", _k = "<< _k << std::endl; tout << "k = " << k << ", _k = "<< _k << std::endl;
); );
expr_ref bound(m); expr_ref bound(m);
expr* e = get_enode(v)->get_expr(); expr* e = get_expr(v);
bound = m_util.mk_ge(e, m_util.mk_numeral(_k, m_util.is_int(e))); bound = m_util.mk_ge(e, m_util.mk_numeral(_k, m_util.is_int(e)));
context & ctx = get_context(); context & ctx = get_context();
{ {
@ -413,7 +413,7 @@ namespace smt {
for (; it != end; ++it) { for (; it != end; ++it) {
if (!it->is_dead() && it->m_var != b && is_free(it->m_var)) { if (!it->is_dead() && it->m_var != b && is_free(it->m_var)) {
theory_var v = it->m_var; theory_var v = it->m_var;
expr* e = get_enode(v)->get_expr(); expr* e = get_expr(v);
bool _is_int = m_util.is_int(e); bool _is_int = m_util.is_int(e);
expr_ref bound(m_util.mk_ge(e, m_util.mk_numeral(rational::zero(), _is_int)), get_manager()); expr_ref bound(m_util.mk_ge(e, m_util.mk_numeral(rational::zero(), _is_int)), get_manager());
context & ctx = get_context(); context & ctx = get_context();
@ -629,9 +629,9 @@ namespace smt {
} }
rational _k = k.to_rational(); rational _k = k.to_rational();
if (is_lower) if (is_lower)
bound = m_util.mk_ge(get_enode(v)->get_expr(), m_util.mk_numeral(_k, is_int(v))); bound = m_util.mk_ge(get_expr(v), m_util.mk_numeral(_k, is_int(v)));
else else
bound = m_util.mk_le(get_enode(v)->get_expr(), m_util.mk_numeral(_k, is_int(v))); bound = m_util.mk_le(get_expr(v), m_util.mk_numeral(_k, is_int(v)));
} }
else { else {
if (num_ints > 0) { if (num_ints > 0) {

2
src/smt/theory_arith_nl.h
View file

@ -653,7 +653,7 @@ theory_var theory_arith<Ext>::find_nl_var_for_branching() {
bool computed_epsilon = false; bool computed_epsilon = false;
bool r = check_monomial_assignment(v, computed_epsilon); bool r = check_monomial_assignment(v, computed_epsilon);
if (!r) { if (!r) {
expr * m = get_enode(v)->get_expr(); expr * m = get_expr(v);
SASSERT(is_pure_monomial(m)); SASSERT(is_pure_monomial(m));
for (expr * arg : *to_app(m)) { for (expr * arg : *to_app(m)) {
theory_var curr = ctx.get_enode(arg)->get_th_var(get_id()); theory_var curr = ctx.get_enode(arg)->get_th_var(get_id());

2
src/smt/theory_arith_pp.h
View file

@ -484,7 +484,7 @@ namespace smt {
pp.set_benchmark_name("lemma"); pp.set_benchmark_name("lemma");
int n = get_num_vars(); int n = get_num_vars();
for (theory_var v = 0; v < n; ++v) { for (theory_var v = 0; v < n; ++v) {
expr * n = get_enode(v)->get_expr(); expr * n = get_expr(v);
if (is_fixed(v)) { if (is_fixed(v)) {
inf_numeral k_inf = lower_bound(v); inf_numeral k_inf = lower_bound(v);
rational k = k_inf.get_rational().to_rational(); rational k = k_inf.get_rational().to_rational();

16
src/smt/theory_array.cpp
View file

@ -42,7 +42,7 @@ namespace smt {
// v1 is the new root // v1 is the new root
TRACE(array, TRACE(array,
tout << "merging v" << v1 << " v" << v2 << "\n"; display_var(tout, v1); tout << "merging v" << v1 << " v" << v2 << "\n"; display_var(tout, v1);
tout << mk_pp(get_enode(v1)->get_expr(), m) << " <- " << mk_pp(get_enode(v2)->get_expr(), m) << "\n";); tout << mk_pp(get_expr(v1), m) << " <- " << mk_pp(get_expr(v2), m) << "\n";);
SASSERT(v1 == find(v1)); SASSERT(v1 == find(v1));
var_data * d1 = m_var_data[v1]; var_data * d1 = m_var_data[v1];
var_data * d2 = m_var_data[v2]; var_data * d2 = m_var_data[v2];
@ -88,7 +88,7 @@ namespace smt {
v = find(v); v = find(v);
var_data * d = m_var_data[v]; var_data * d = m_var_data[v];
d->m_parent_selects.push_back(s); d->m_parent_selects.push_back(s);
TRACE(array, tout << v << " " << mk_pp(s->get_expr(), m) << " " << mk_pp(get_enode(v)->get_expr(), m) << "\n";); TRACE(array, tout << v << " " << mk_pp(s->get_expr(), m) << " " << mk_pp(get_expr(v), m) << "\n";);
m_trail_stack.push(push_back_trail<enode *, false>(d->m_parent_selects)); m_trail_stack.push(push_back_trail<enode *, false>(d->m_parent_selects));
for (enode* n : d->m_stores) for (enode* n : d->m_stores)
instantiate_axiom2a(s, n); instantiate_axiom2a(s, n);
@ -299,8 +299,8 @@ namespace smt {
void theory_array::new_eq_eh(theory_var v1, theory_var v2) { void theory_array::new_eq_eh(theory_var v1, theory_var v2) {
m_find.merge(v1, v2); m_find.merge(v1, v2);
enode* n1 = get_enode(v1), *n2 = get_enode(v2); enode* n1 = get_enode(v1), *n2 = get_enode(v2);
if (n1->get_expr()->get_decl()->is_lambda() || if (n1->get_decl()->is_lambda() ||
n2->get_expr()->get_decl()->is_lambda()) { n2->get_decl()->is_lambda()) {
assert_congruent(n1, n2); assert_congruent(n1, n2);
} }
} }
@ -310,8 +310,8 @@ namespace smt {
v2 = find(v2); v2 = find(v2);
var_data * d1 = m_var_data[v1]; var_data * d1 = m_var_data[v1];
TRACE(ext, tout << "extensionality: " << d1->m_is_array << "\n" TRACE(ext, tout << "extensionality: " << d1->m_is_array << "\n"
<< mk_bounded_pp(get_enode(v1)->get_expr(), m, 5) << "\n" << mk_bounded_pp(get_expr(v1), m, 5) << "\n"
<< mk_bounded_pp(get_enode(v2)->get_expr(), m, 5) << "\n";); << mk_bounded_pp(get_expr(v2), m, 5) << "\n";);
if (d1->m_is_array) { if (d1->m_is_array) {
SASSERT(m_var_data[v2]->m_is_array); SASSERT(m_var_data[v2]->m_is_array);
@ -319,7 +319,7 @@ namespace smt {
} }
} }
void theory_array::relevant_eh(app * n) { void theory_array::relevant_eh(expr * n) {
if (laziness() == 0) if (laziness() == 0)
return; return;
if (m.is_ite(n)) { if (m.is_ite(n)) {
@ -328,7 +328,7 @@ namespace smt {
if (!is_store(n) && !is_select(n)) if (!is_store(n) && !is_select(n))
return; return;
if (!ctx.e_internalized(n)) ctx.internalize(n, false); if (!ctx.e_internalized(n)) ctx.internalize(n, false);
enode * arg = ctx.get_enode(n->get_arg(0)); enode * arg = ctx.get_enode(to_app(n)->get_arg(0));
theory_var v_arg = arg->get_th_var(get_id()); theory_var v_arg = arg->get_th_var(get_id());
SASSERT(v_arg != null_theory_var); SASSERT(v_arg != null_theory_var);

2
src/smt/theory_array.h
View file

@ -59,7 +59,7 @@ namespace smt {
void apply_sort_cnstr(enode * n, sort * s) override; void apply_sort_cnstr(enode * n, sort * s) override;
void new_eq_eh(theory_var v1, theory_var v2) override; void new_eq_eh(theory_var v1, theory_var v2) override;
void new_diseq_eh(theory_var v1, theory_var v2) override; void new_diseq_eh(theory_var v1, theory_var v2) override;
void relevant_eh(app * n) override; void relevant_eh(expr * n) override;
void push_scope_eh() override; void push_scope_eh() override;
void pop_scope_eh(unsigned num_scopes) override; void pop_scope_eh(unsigned num_scopes) override;
final_check_status final_check_eh(unsigned) override; final_check_status final_check_eh(unsigned) override;

26
src/smt/theory_array_base.cpp
View file

@ -108,7 +108,7 @@ namespace smt {
} }
void theory_array_base::assert_store_axiom1_core(enode * e) { void theory_array_base::assert_store_axiom1_core(enode * e) {
app * n = e->get_expr(); app * n = e->get_app();
SASSERT(is_store(n)); SASSERT(is_store(n));
ptr_buffer<expr> sel_args; ptr_buffer<expr> sel_args;
unsigned num_args = n->get_num_args(); unsigned num_args = n->get_num_args();
@ -235,10 +235,6 @@ namespace smt {
return false; return false;
} }
func_decl_ref_vector * theory_array_base::register_sort(sort * s_array) { func_decl_ref_vector * theory_array_base::register_sort(sort * s_array) {
unsigned dimension = get_dimension(s_array); unsigned dimension = get_dimension(s_array);
func_decl_ref_vector * ext_skolems = nullptr; func_decl_ref_vector * ext_skolems = nullptr;
@ -333,8 +329,8 @@ namespace smt {
void theory_array_base::assert_extensionality_core(enode * n1, enode * n2) { void theory_array_base::assert_extensionality_core(enode * n1, enode * n2) {
app * e1 = n1->get_expr(); expr * e1 = n1->get_expr();
app * e2 = n2->get_expr(); expr * e2 = n2->get_expr();
func_decl_ref_vector * funcs = nullptr; func_decl_ref_vector * funcs = nullptr;
sort * s = e1->get_sort(); sort * s = e1->get_sort();
@ -371,8 +367,8 @@ namespace smt {
\brief assert n1 = n2 => forall vars . (n1 vars) = (n2 vars) \brief assert n1 = n2 => forall vars . (n1 vars) = (n2 vars)
*/ */
void theory_array_base::assert_congruent_core(enode * n1, enode * n2) { void theory_array_base::assert_congruent_core(enode * n1, enode * n2) {
app * e1 = n1->get_expr(); expr * e1 = n1->get_expr();
app * e2 = n2->get_expr(); expr * e2 = n2->get_expr();
sort* s = e1->get_sort(); sort* s = e1->get_sort();
unsigned dimension = get_array_arity(s); unsigned dimension = get_array_arity(s);
literal n1_eq_n2 = mk_eq(e1, e2, true); literal n1_eq_n2 = mk_eq(e1, e2, true);
@ -403,13 +399,13 @@ namespace smt {
assert_axiom(~n1_eq_n2, fa_eq); assert_axiom(~n1_eq_n2, fa_eq);
} }
expr_ref theory_array_base::instantiate_lambda(app* e) { expr_ref theory_array_base::instantiate_lambda(expr* e) {
quantifier * q = m.is_lambda_def(e->get_decl()); quantifier * q = m.is_lambda_def(e);
expr_ref f(e, m); expr_ref f(e, m);
if (q) { if (q) {
// the variables in q are maybe not consecutive. // the variables in q are maybe not consecutive.
var_subst sub(m, false); var_subst sub(m, false);
f = sub(q, e->get_num_args(), e->get_args()); f = sub(q, to_app(e)->get_num_args(), to_app(e)->get_args());
} }
return f; return f;
} }
@ -561,13 +557,13 @@ namespace smt {
TRACE(array_bug, tout << "mk_interface_eqs: processing: v" << *it1 << "\n";); TRACE(array_bug, tout << "mk_interface_eqs: processing: v" << *it1 << "\n";);
theory_var v1 = *it1; theory_var v1 = *it1;
enode * n1 = get_enode(v1); enode * n1 = get_enode(v1);
sort * s1 = n1->get_expr()->get_sort(); sort * s1 = n1->get_sort();
sbuffer<theory_var>::iterator it2 = it1; sbuffer<theory_var>::iterator it2 = it1;
++it2; ++it2;
for (; it2 != end1; ++it2) { for (; it2 != end1; ++it2) {
theory_var v2 = *it2; theory_var v2 = *it2;
enode * n2 = get_enode(v2); enode * n2 = get_enode(v2);
sort * s2 = n2->get_expr()->get_sort(); sort * s2 = n2->get_sort();
if (s1 == s2 && !ctx.is_diseq(n1, n2)) { if (s1 == s2 && !ctx.is_diseq(n1, n2)) {
app * eq = mk_eq_atom(n1->get_expr(), n2->get_expr()); app * eq = mk_eq_atom(n1->get_expr(), n2->get_expr());
if (!ctx.b_internalized(eq) || !ctx.is_relevant(eq)) { if (!ctx.b_internalized(eq) || !ctx.is_relevant(eq)) {
@ -974,7 +970,7 @@ namespace smt {
model_value_proc * theory_array_base::mk_value(enode * n, model_generator & mg) { model_value_proc * theory_array_base::mk_value(enode * n, model_generator & mg) {
theory_var v = n->get_th_var(get_id()); theory_var v = n->get_th_var(get_id());
SASSERT(v != null_theory_var); SASSERT(v != null_theory_var);
sort * s = n->get_expr()->get_sort(); sort * s = n->get_sort();
enode * else_val_n = get_default(v); enode * else_val_n = get_default(v);
array_value_proc * result = nullptr; array_value_proc * result = nullptr;

26
src/smt/theory_array_base.h
View file

@ -33,19 +33,19 @@ namespace smt {
void add_weak_var(theory_var v); void add_weak_var(theory_var v);
virtual void set_prop_upward(theory_var v) {} virtual void set_prop_upward(theory_var v) {}
void found_unsupported_op(expr * n); void found_unsupported_op(expr * n);
void found_unsupported_op(enode* n) { found_unsupported_op(n->get_expr()); } void found_unsupported_op(enode* n) { found_unsupported_op(n->get_app()); }
void found_unsupported_op(theory_var v) { found_unsupported_op(get_enode(v)->get_expr()); } void found_unsupported_op(theory_var v) { found_unsupported_op(get_enode(v)->get_app()); }
bool is_store(app const* n) const { return n->is_app_of(get_id(), OP_STORE); } bool is_store(expr const* n) const { return is_app(n) && to_app(n)->is_app_of(get_id(), OP_STORE); }
bool is_map(app const* n) const { return n->is_app_of(get_id(), OP_ARRAY_MAP); } bool is_map(expr const* n) const { return is_app(n) && to_app(n)->is_app_of(get_id(), OP_ARRAY_MAP); }
bool is_select(app const* n) const { return n->is_app_of(get_id(), OP_SELECT); } bool is_select(expr const* n) const { return is_app(n) && to_app(n)->is_app_of(get_id(), OP_SELECT); }
bool is_default(app const* n) const { return n->is_app_of(get_id(), OP_ARRAY_DEFAULT); } bool is_default(expr const* n) const { return is_app(n) && to_app(n)->is_app_of(get_id(), OP_ARRAY_DEFAULT); }
bool is_const(app const* n) const { return n->is_app_of(get_id(), OP_CONST_ARRAY); } bool is_const(expr const* n) const { return is_app(n) && to_app(n)->is_app_of(get_id(), OP_CONST_ARRAY); }
bool is_array_ext(app const * n) const { return n->is_app_of(get_id(), OP_ARRAY_EXT); } bool is_array_ext(expr const * n) const { return is_app(n) && to_app(n)->is_app_of(get_id(), OP_ARRAY_EXT); }
bool is_as_array(app const * n) const { return n->is_app_of(get_id(), OP_AS_ARRAY); } bool is_as_array(expr const * n) const { return is_app(n) && to_app(n)->is_app_of(get_id(), OP_AS_ARRAY); }
bool is_choice(app const* n) const { return n->is_app_of(get_id(), OP_CHOICE); } bool is_choice(expr const* n) const { return is_app(n) && to_app(n)->is_app_of(get_id(), OP_CHOICE); }
bool is_array_sort(sort const* s) const { return s->is_sort_of(get_id(), ARRAY_SORT); } bool is_array_sort(sort const* s) const { return s->is_sort_of(get_id(), ARRAY_SORT); }
bool is_array_sort(app const* n) const { return is_array_sort(n->get_sort()); } bool is_array_sort(expr const* n) const { return is_array_sort(n->get_sort()); }
bool is_store(enode const * n) const { return is_store(n->get_expr()); } bool is_store(enode const * n) const { return is_store(n->get_expr()); }
bool is_map(enode const* n) const { return is_map(n->get_expr()); } bool is_map(enode const* n) const { return is_map(n->get_expr()); }
@ -54,7 +54,7 @@ namespace smt {
bool is_as_array(enode const * n) const { return is_as_array(n->get_expr()); } bool is_as_array(enode const * n) const { return is_as_array(n->get_expr()); }
bool is_choice(enode const* n) const { return is_choice(n->get_expr()); } bool is_choice(enode const* n) const { return is_choice(n->get_expr()); }
bool is_default(enode const* n) const { return is_default(n->get_expr()); } bool is_default(enode const* n) const { return is_default(n->get_expr()); }
bool is_array_sort(enode const* n) const { return is_array_sort(n->get_expr()); } bool is_array_sort(enode const* n) const { return is_array_sort(n->get_sort()); }
bool is_select_arg(enode* r); bool is_select_arg(enode* r);
app * mk_select(unsigned num_args, expr * const * args); app * mk_select(unsigned num_args, expr * const * args);
@ -82,7 +82,7 @@ namespace smt {
void assert_extensionality_core(enode * a1, enode * a2); void assert_extensionality_core(enode * a1, enode * a2);
bool assert_extensionality(enode * a1, enode * a2); bool assert_extensionality(enode * a1, enode * a2);
expr_ref instantiate_lambda(app* e); expr_ref instantiate_lambda(expr* e);
void assert_congruent_core(enode * a1, enode * a2); void assert_congruent_core(enode * a1, enode * a2);
void assert_congruent(enode * a1, enode * a2); void assert_congruent(enode * a1, enode * a2);

40
src/smt/theory_array_full.cpp
View file

@ -248,7 +248,7 @@ namespace smt {
instantiate_default_as_array_axiom(n); instantiate_default_as_array_axiom(n);
d->m_as_arrays.push_back(n); d->m_as_arrays.push_back(n);
} }
else if (m.is_lambda_def(n->get_decl())) { else if (m.is_lambda_def(n->get_expr())) {
instantiate_default_lambda_def_axiom(n); instantiate_default_lambda_def_axiom(n);
d->m_lambdas.push_back(n); d->m_lambdas.push_back(n);
m_lambdas.push_back(n); m_lambdas.push_back(n);
@ -406,22 +406,23 @@ namespace smt {
} }
} }
void theory_array_full::relevant_eh(app* n) { void theory_array_full::relevant_eh(expr* n) {
TRACE(array, tout << mk_pp(n, m) << "\n";); TRACE(array, tout << mk_pp(n, m) << "\n";);
theory_array::relevant_eh(n); theory_array::relevant_eh(n);
if (!is_default(n) && !is_select(n) && !is_map(n) && !is_const(n) && !is_as_array(n) && !is_choice(n)){ if (!is_default(n) && !is_select(n) && !is_map(n) &&
!is_const(n) && !is_as_array(n) && !is_choice(n) && !is_lambda(n)){
return; return;
} }
ctx.ensure_internalized(n); ctx.ensure_internalized(n);
enode* node = ctx.get_enode(n); enode* node = ctx.get_enode(n);
if (is_select(n)) { if (is_select(n)) {
enode * arg = ctx.get_enode(n->get_arg(0)); enode * arg = ctx.get_enode(to_app(n)->get_arg(0));
theory_var v = arg->get_th_var(get_id()); theory_var v = arg->get_th_var(get_id());
SASSERT(v != null_theory_var); SASSERT(v != null_theory_var);
add_parent_select(find(v), node); add_parent_select(find(v), node);
} }
else if (is_default(n)) { else if (is_default(n)) {
enode * arg = ctx.get_enode(n->get_arg(0)); enode * arg = ctx.get_enode(to_app(n)->get_arg(0));
theory_var v = arg->get_th_var(get_id()); theory_var v = arg->get_th_var(get_id());
SASSERT(v != null_theory_var); SASSERT(v != null_theory_var);
set_prop_upward(v); set_prop_upward(v);
@ -434,7 +435,7 @@ namespace smt {
add_parent_default(find(v)); add_parent_default(find(v));
} }
else if (is_map(n)) { else if (is_map(n)) {
for (expr * e : *n) { for (expr * e : *to_app(n)) {
enode* arg = ctx.get_enode(e); enode* arg = ctx.get_enode(e);
theory_var v_arg = find(arg->get_th_var(get_id())); theory_var v_arg = find(arg->get_th_var(get_id()));
add_parent_map(v_arg, node); add_parent_map(v_arg, node);
@ -448,6 +449,9 @@ namespace smt {
else if (is_choice(n)) { else if (is_choice(n)) {
instantiate_choice_axiom(node); instantiate_choice_axiom(node);
} }
else if (is_lambda(n)) {
NOT_IMPLEMENTED_YET();
}
} }
bool theory_array_full::should_research(expr_ref_vector & unsat_core) { bool theory_array_full::should_research(expr_ref_vector & unsat_core) {
@ -462,8 +466,8 @@ namespace smt {
// select(map[f](a, ... d), i) = f(select(a,i),...,select(d,i)) // select(map[f](a, ... d), i) = f(select(a,i),...,select(d,i))
// //
bool theory_array_full::instantiate_select_map_axiom(enode* sl, enode* mp) { bool theory_array_full::instantiate_select_map_axiom(enode* sl, enode* mp) {
app* map = mp->get_expr(); app* map = mp->get_app();
app* select = sl->get_expr(); app* select = sl->get_app();
SASSERT(is_map(map)); SASSERT(is_map(map));
SASSERT(is_select(select)); SASSERT(is_select(select));
SASSERT(map->get_num_args() > 0); SASSERT(map->get_num_args() > 0);
@ -529,7 +533,7 @@ namespace smt {
bool theory_array_full::instantiate_default_map_axiom(enode* mp) { bool theory_array_full::instantiate_default_map_axiom(enode* mp) {
SASSERT(is_map(mp)); SASSERT(is_map(mp));
app* map = mp->get_expr(); app* map = mp->get_app();
if (!ctx.add_fingerprint(this, m_default_map_fingerprint, 1, &mp)) { if (!ctx.add_fingerprint(this, m_default_map_fingerprint, 1, &mp)) {
return false; return false;
} }
@ -581,7 +585,7 @@ namespace smt {
m_stats.m_num_default_lambda_axiom++; m_stats.m_num_default_lambda_axiom++;
expr* e = arr->get_expr(); expr* e = arr->get_expr();
expr_ref def(mk_default(e), m); expr_ref def(mk_default(e), m);
quantifier* lam = m.is_lambda_def(arr->get_decl()); quantifier* lam = m.is_lambda_def(e);
TRACE(array, tout << mk_pp(lam, m) << "\n" << mk_pp(e, m) << "\n"); TRACE(array, tout << mk_pp(lam, m) << "\n" << mk_pp(e, m) << "\n");
expr_ref_vector args(m); expr_ref_vector args(m);
var_subst subst(m, false); var_subst subst(m, false);
@ -607,7 +611,7 @@ namespace smt {
return false; return false;
++m_stats.m_num_choice_axiom; ++m_stats.m_num_choice_axiom;
SASSERT(is_choice(ch)); SASSERT(is_choice(ch));
app* choice_term = ch->get_expr(); app* choice_term = ch->get_app();
expr* pred = choice_term->get_arg(0); expr* pred = choice_term->get_arg(0);
sort* pred_sort = pred->get_sort(); sort* pred_sort = pred->get_sort();
SASSERT(is_array_sort(pred_sort)); SASSERT(is_array_sort(pred_sort));
@ -645,10 +649,10 @@ namespace smt {
ptr_buffer<expr> sel_args; ptr_buffer<expr> sel_args;
sel_args.push_back(cnst->get_expr()); sel_args.push_back(cnst->get_expr());
for (unsigned short i = 1; i < num_args; ++i) { for (unsigned short i = 1; i < num_args; ++i) {
sel_args.push_back(select->get_expr()->get_arg(i)); sel_args.push_back(select->get_app()->get_arg(i));
} }
expr * sel = mk_select(sel_args.size(), sel_args.data()); expr * sel = mk_select(sel_args.size(), sel_args.data());
expr * val = cnst->get_expr()->get_arg(0); expr * val = cnst->get_app()->get_arg(0);
TRACE(array, tout << "new select-const axiom...\n"; TRACE(array, tout << "new select-const axiom...\n";
tout << "const: " << mk_bounded_pp(cnst->get_expr(), m) << "\n"; tout << "const: " << mk_bounded_pp(cnst->get_expr(), m) << "\n";
tout << "select: " << mk_bounded_pp(select->get_expr(), m) << "\n"; tout << "select: " << mk_bounded_pp(select->get_expr(), m) << "\n";
@ -667,7 +671,7 @@ namespace smt {
// select(as-array f, i_1, ..., i_n) = (f i_1 ... i_n) // select(as-array f, i_1, ..., i_n) = (f i_1 ... i_n)
// //
bool theory_array_full::instantiate_select_as_array_axiom(enode* select, enode* arr) { bool theory_array_full::instantiate_select_as_array_axiom(enode* select, enode* arr) {
SASSERT(is_as_array(arr->get_expr())); SASSERT(is_as_array(arr->get_app()));
SASSERT(is_select(select)); SASSERT(is_select(select));
SASSERT(arr->get_num_args() == 0); SASSERT(arr->get_num_args() == 0);
unsigned num_args = select->get_num_args(); unsigned num_args = select->get_num_args();
@ -677,12 +681,12 @@ namespace smt {
m_stats.m_num_select_as_array_axiom++; m_stats.m_num_select_as_array_axiom++;
ptr_buffer<expr> sel_args; ptr_buffer<expr> sel_args;
sel_args.push_back(arr->get_expr()); sel_args.push_back(arr->get_app());
for (unsigned short i = 1; i < num_args; ++i) { for (unsigned short i = 1; i < num_args; ++i) {
sel_args.push_back(select->get_expr()->get_arg(i)); sel_args.push_back(select->get_app()->get_arg(i));
} }
expr * sel = mk_select(sel_args.size(), sel_args.data()); expr * sel = mk_select(sel_args.size(), sel_args.data());
func_decl * f = array_util(m).get_as_array_func_decl(arr->get_expr()); func_decl * f = array_util(m).get_as_array_func_decl(arr->get_app());
expr_ref val(m.mk_app(f, sel_args.size()-1, sel_args.data()+1), m); expr_ref val(m.mk_app(f, sel_args.size()-1, sel_args.data()+1), m);
TRACE(array, tout << "new select-as-array axiom...\n"; TRACE(array, tout << "new select-as-array axiom...\n";
tout << "as-array: " << mk_bounded_pp(arr->get_expr(), m) << "\n"; tout << "as-array: " << mk_bounded_pp(arr->get_expr(), m) << "\n";
@ -701,7 +705,7 @@ namespace smt {
bool theory_array_full::instantiate_default_store_axiom(enode* store) { bool theory_array_full::instantiate_default_store_axiom(enode* store) {
SASSERT(is_store(store)); SASSERT(is_store(store));
SASSERT(store->get_num_args() >= 3); SASSERT(store->get_num_args() >= 3);
app* store_app = store->get_expr(); app* store_app = store->get_app();
if (!ctx.add_fingerprint(this, m_default_store_fingerprint, store->get_num_args(), store->get_args())) { if (!ctx.add_fingerprint(this, m_default_store_fingerprint, store->get_num_args(), store->get_args())) {
return false; return false;
} }

3
src/smt/theory_array_full.h
View file

@ -60,7 +60,7 @@ namespace smt {
bool internalize_atom(app * atom, bool gate_ctx) override; bool internalize_atom(app * atom, bool gate_ctx) override;
void pop_scope_eh(unsigned num_scopes) override; void pop_scope_eh(unsigned num_scopes) override;
theory_var mk_var(enode * n) override; theory_var mk_var(enode * n) override;
void relevant_eh(app * n) override; void relevant_eh(expr * n) override;
bool should_research(expr_ref_vector & unsat_core) override; bool should_research(expr_ref_vector & unsat_core) override;
void add_theory_assumptions(expr_ref_vector & assumptions) override; void add_theory_assumptions(expr_ref_vector & assumptions) override;
@ -81,6 +81,7 @@ namespace smt {
bool instantiate_default_map_axiom(enode* map); bool instantiate_default_map_axiom(enode* map);
bool instantiate_default_as_array_axiom(enode* arr); bool instantiate_default_as_array_axiom(enode* arr);
bool instantiate_default_lambda_def_axiom(enode* arr); bool instantiate_default_lambda_def_axiom(enode* arr);
bool instantiate_select_lambda_axiom(enode *lambda);
bool instantiate_choice_axiom(enode* ch); bool instantiate_choice_axiom(enode* ch);
bool instantiate_parent_stores_default(theory_var v); bool instantiate_parent_stores_default(theory_var v);

49
src/smt/theory_bv.cpp
View file

@ -38,7 +38,7 @@ namespace smt {
return r; return r;
} }
app * theory_bv::mk_bit2bool(app * bv, unsigned idx) { app * theory_bv::mk_bit2bool(expr * bv, unsigned idx) {
parameter p(idx); parameter p(idx);
expr * args[1] = {bv}; expr * args[1] = {bv};
return get_manager().mk_app(get_id(), OP_BIT2BOOL, 1, &p, 1, args); return get_manager().mk_app(get_id(), OP_BIT2BOOL, 1, &p, 1, args);
@ -46,7 +46,7 @@ namespace smt {
void theory_bv::mk_bits(theory_var v) { void theory_bv::mk_bits(theory_var v) {
enode * n = get_enode(v); enode * n = get_enode(v);
app * owner = n->get_expr(); expr * owner = n->get_expr();
unsigned bv_size = get_bv_size(n); unsigned bv_size = get_bv_size(n);
bool is_relevant = ctx.is_relevant(n); bool is_relevant = ctx.is_relevant(n);
literal_vector & bits = m_bits[v]; literal_vector & bits = m_bits[v];
@ -180,7 +180,7 @@ namespace smt {
return n->get_arg(idx); return n->get_arg(idx);
} }
else { else {
app * arg = to_app(n->get_expr()->get_arg(idx)); app * arg = to_app(n->get_app()->get_arg(idx));
SASSERT(ctx.e_internalized(arg)); SASSERT(ctx.e_internalized(arg));
return ctx.get_enode(arg); return ctx.get_enode(arg);
} }
@ -236,8 +236,8 @@ namespace smt {
TRACE(bv_diseq_axiom, tout << "found new diseq axiom\n"; display_var(tout, v1); display_var(tout, v2);); TRACE(bv_diseq_axiom, tout << "found new diseq axiom\n"; display_var(tout, v1); display_var(tout, v2););
// found new disequality // found new disequality
m_stats.m_num_diseq_static++; m_stats.m_num_diseq_static++;
app * e1 = get_expr(v1); expr * e1 = get_expr(v1);
app * e2 = get_expr(v2); expr * e2 = get_expr(v2);
expr_ref eq(m.mk_eq(e1, e2), m); expr_ref eq(m.mk_eq(e1, e2), m);
literal l = ~mk_literal(eq); literal l = ~mk_literal(eq);
std::function<expr*(void)> logfn = [&]() { std::function<expr*(void)> logfn = [&]() {
@ -438,8 +438,8 @@ namespace smt {
return; return;
} }
++m_stats.m_num_eq_dynamic; ++m_stats.m_num_eq_dynamic;
app* o1 = get_enode(v1)->get_expr(); expr* o1 = get_expr(v1);
app* o2 = get_enode(v2)->get_expr(); expr* o2 = get_expr(v2);
literal oeq = mk_eq(o1, o2, true); literal oeq = mk_eq(o1, o2, true);
ctx.mark_as_relevant(oeq); ctx.mark_as_relevant(oeq);
@ -475,7 +475,7 @@ namespace smt {
VERIFY(get_fixed_value(v, val)); VERIFY(get_fixed_value(v, val));
enode* n = get_enode(v); enode* n = get_enode(v);
if (ctx.watches_fixed(n)) { if (ctx.watches_fixed(n)) {
expr_ref num(m_util.mk_numeral(val, n->get_expr()->get_sort()), m); expr_ref num(m_util.mk_numeral(val, n->get_sort()), m);
literal_vector& lits = m_tmp_literals; literal_vector& lits = m_tmp_literals;
lits.reset(); lits.reset();
for (literal b : m_bits[v]) { for (literal b : m_bits[v]) {
@ -1124,14 +1124,17 @@ namespace smt {
// Determine whether bit-vector expression should be approximated // Determine whether bit-vector expression should be approximated
// based on the number of bits used by the arguments. // based on the number of bits used by the arguments.
// //
bool theory_bv::approximate_term(app* n) { bool theory_bv::approximate_term(expr *e) {
if (params().m_bv_blast_max_size == INT_MAX) { if (params().m_bv_blast_max_size == INT_MAX) {
return false; return false;
} }
if (!is_app(e))
return false;
app *n = to_app(e);
unsigned num_args = n->get_num_args(); unsigned num_args = n->get_num_args();
for (unsigned i = 0; i <= num_args; ++i) { for (unsigned i = 0; i <= num_args; ++i) {
expr* arg = (i == num_args)?n:n->get_arg(i); expr *arg = (i == num_args) ? n : n->get_arg(i);
sort* s = arg->get_sort(); sort *s = arg->get_sort();
if (m_util.is_bv_sort(s) && m_util.get_bv_size(arg) > params().m_bv_blast_max_size) { if (m_util.is_bv_sort(s) && m_util.get_bv_size(arg) > params().m_bv_blast_max_size) {
if (!m_approximates_large_bvs) { if (!m_approximates_large_bvs) {
TRACE(bv, tout << "found large size bit-vector:\n" << mk_pp(n, m) << "\n";); TRACE(bv, tout << "found large size bit-vector:\n" << mk_pp(n, m) << "\n";);
@ -1148,13 +1151,13 @@ namespace smt {
if (!is_attached_to_var(n) && !approximate_term(n->get_expr())) { if (!is_attached_to_var(n) && !approximate_term(n->get_expr())) {
mk_bits(mk_var(n)); mk_bits(mk_var(n));
if (ctx.is_relevant(n)) { if (ctx.is_relevant(n)) {
relevant_eh(n->get_expr()); relevant_eh(n->get_app());
} }
} }
} }
void theory_bv::new_eq_eh(theory_var v1, theory_var v2) { void theory_bv::new_eq_eh(theory_var v1, theory_var v2) {
TRACE(bv_eq, tout << "new_eq: " << mk_pp(get_enode(v1)->get_expr(), m) << " = " << mk_pp(get_enode(v2)->get_expr(), m) << "\n";); TRACE(bv_eq, tout << "new_eq: " << mk_pp(get_expr(v1), m) << " = " << mk_pp(get_expr(v2), m) << "\n";);
TRACE(bv, tout << "new_eq_eh v" << v1 << " = v" << v2 << " @ " << ctx.get_scope_level() << TRACE(bv, tout << "new_eq_eh v" << v1 << " = v" << v2 << " @ " << ctx.get_scope_level() <<
" relevant1: " << ctx.is_relevant(get_enode(v1)) << " relevant1: " << ctx.is_relevant(get_enode(v1)) <<
" relevant2: " << ctx.is_relevant(get_enode(v2)) << "\n";); " relevant2: " << ctx.is_relevant(get_enode(v2)) << "\n";);
@ -1218,7 +1221,7 @@ namespace smt {
literal_vector & lits = m_tmp_literals; literal_vector & lits = m_tmp_literals;
lits.reset(); lits.reset();
literal eq = mk_eq(get_enode(v1)->get_expr(), get_enode(v2)->get_expr(), true); literal eq = mk_eq(get_expr(v1), get_expr(v2), true);
lits.push_back(eq); lits.push_back(eq);
it1 = bits1.begin(); it1 = bits1.begin();
it2 = bits2.begin(); it2 = bits2.begin();
@ -1232,7 +1235,7 @@ namespace smt {
lits.push_back(arg); lits.push_back(arg);
} }
TRACE(bv, TRACE(bv,
tout << mk_pp(get_enode(v1)->get_expr(), m) << " = " << mk_pp(get_enode(v2)->get_expr(), m) << " " tout << mk_pp(get_expr(v1), m) << " = " << mk_pp(get_expr(v2), m) << " "
<< ctx.get_scope_level() << ctx.get_scope_level()
<< "\n"; << "\n";
ctx.display_literals_smt2(tout, lits);); ctx.display_literals_smt2(tout, lits););
@ -1385,7 +1388,7 @@ namespace smt {
} }
} }
void theory_bv::relevant_eh(app * n) { void theory_bv::relevant_eh(expr * n) {
TRACE(arith, tout << "relevant: #" << n->get_id() << " " << ctx.e_internalized(n) << ": " << mk_bounded_pp(n, m) << "\n";); TRACE(arith, tout << "relevant: #" << n->get_id() << " " << ctx.e_internalized(n) << ": " << mk_bounded_pp(n, m) << "\n";);
TRACE(bv, tout << "relevant: #" << n->get_id() << " " << ctx.e_internalized(n) << ": " << mk_pp(n, m) << "\n";); TRACE(bv, tout << "relevant: #" << n->get_id() << " " << ctx.e_internalized(n) << ": " << mk_pp(n, m) << "\n";);
if (m.is_bool(n)) { if (m.is_bool(n)) {
@ -1403,18 +1406,18 @@ namespace smt {
} }
} }
else if (params().m_bv_enable_int2bv2int && m_util.is_ubv2int(n)) { else if (params().m_bv_enable_int2bv2int && m_util.is_ubv2int(n)) {
ctx.mark_as_relevant(n->get_arg(0)); ctx.mark_as_relevant(to_app(n)->get_arg(0));
assert_bv2int_axiom(n); assert_bv2int_axiom(to_app(n));
} }
else if (params().m_bv_enable_int2bv2int && m_util.is_int2bv(n)) { else if (params().m_bv_enable_int2bv2int && m_util.is_int2bv(n)) {
ctx.mark_as_relevant(n->get_arg(0)); ctx.mark_as_relevant(to_app(n)->get_arg(0));
assert_int2bv_axiom(n); assert_int2bv_axiom(to_app(n));
} }
#if ENABLE_QUOT_REM_ENCODING #if ENABLE_QUOT_REM_ENCODING
else if (m_util.is_bv_udivi(n)) { else if (m_util.is_bv_udivi(n)) {
ctx.mark_as_relevant(n->get_arg(0)); ctx.mark_as_relevant(to_app(n)->get_arg(0));
ctx.mark_as_relevant(n->get_arg(1)); ctx.mark_as_relevant(to_app(n)->get_arg(1));
assert_udiv_quot_rem_axiom(n); assert_udiv_quot_rem_axiom(to_app(n));
} }
#endif #endif
else if (ctx.e_internalized(n)) { else if (ctx.e_internalized(n)) {

12
src/smt/theory_bv.h
View file

@ -142,15 +142,15 @@ namespace smt {
theory_var next(theory_var v) const { return m_find.next(v); } theory_var next(theory_var v) const { return m_find.next(v); }
bool is_root(theory_var v) const { return m_find.is_root(v); } bool is_root(theory_var v) const { return m_find.is_root(v); }
unsigned get_bv_size(app const * n) const { return m_util.get_bv_size(n); } unsigned get_bv_size(app const * n) const { return m_util.get_bv_size(n); }
unsigned get_bv_size(enode const * n) const { return m_util.get_bv_size(n->get_expr()); } unsigned get_bv_size(enode const * n) const { return m_util.get_bv_size(n->get_app()); }
unsigned get_bv_size(theory_var v) const { return get_bv_size(get_enode(v)); } unsigned get_bv_size(theory_var v) const { return get_bv_size(get_enode(v)); }
bool is_bv(app const* n) const { return m_util.is_bv_sort(n->get_sort()); } bool is_bv(app const* n) const { return m_util.is_bv_sort(n->get_sort()); }
bool is_bv(enode const* n) const { return is_bv(n->get_expr()); } bool is_bv(enode const* n) const { return is_bv(n->get_app()); }
bool is_bv(theory_var v) const { return is_bv(get_enode(v)); } bool is_bv(theory_var v) const { return is_bv(get_enode(v)); }
region & get_region() { return m_trail_stack.get_region(); } region & get_region() { return m_trail_stack.get_region(); }
bool is_numeral(theory_var v) const { return m_util.is_numeral(get_enode(v)->get_expr()); } bool is_numeral(theory_var v) const { return m_util.is_numeral(get_expr(v)); }
app * mk_bit2bool(app * bv, unsigned idx); app * mk_bit2bool(expr * bv, unsigned idx);
void mk_bits(theory_var v); void mk_bits(theory_var v);
friend class mk_atom_trail; friend class mk_atom_trail;
void mk_bit2bool(app * n); void mk_bit2bool(app * n);
@ -217,7 +217,7 @@ namespace smt {
void internalize_smul_no_overflow(app *n); void internalize_smul_no_overflow(app *n);
void internalize_smul_no_underflow(app *n); void internalize_smul_no_underflow(app *n);
bool approximate_term(app* n); bool approximate_term(expr* e);
template<bool Signed> template<bool Signed>
void internalize_le(app * atom); void internalize_le(app * atom);
@ -240,7 +240,7 @@ namespace smt {
void new_diseq_eh(theory_var v1, theory_var v2) override; void new_diseq_eh(theory_var v1, theory_var v2) override;
virtual void expand_diseq(theory_var v1, theory_var v2); virtual void expand_diseq(theory_var v1, theory_var v2);
void assign_eh(bool_var v, bool is_true) override; void assign_eh(bool_var v, bool is_true) override;
void relevant_eh(app * n) override; void relevant_eh(expr * n) override;
void push_scope_eh() override; void push_scope_eh() override;
void pop_scope_eh(unsigned num_scopes) override; void pop_scope_eh(unsigned num_scopes) override;
final_check_status final_check_eh(unsigned) override; final_check_status final_check_eh(unsigned) override;

32
src/smt/theory_datatype.cpp
View file

@ -138,7 +138,7 @@ namespace smt {
where acc_i are the accessors of constructor c. where acc_i are the accessors of constructor c.
*/ */
void theory_datatype::assert_is_constructor_axiom(enode * n, func_decl * c, literal antecedent) { void theory_datatype::assert_is_constructor_axiom(enode * n, func_decl * c, literal antecedent) {
app* e = n->get_expr(); app* e = n->get_app();
TRACE(datatype_bug, tout << "creating axiom (= n (c (acc_1 n) ... (acc_m n))) for\n" 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";); << mk_pp(c, m) << " " << mk_pp(e, m) << "\n";);
m_stats.m_assert_cnstr++; m_stats.m_assert_cnstr++;
@ -175,12 +175,12 @@ namespace smt {
vector<std::tuple<enode *, enode *>> used_enodes; vector<std::tuple<enode *, enode *>> used_enodes;
used_enodes.push_back(std::make_tuple(nullptr, n)); used_enodes.push_back(std::make_tuple(nullptr, n));
for (unsigned i = 0; i < n->get_num_args(); ++i) { for (unsigned i = 0; i < n->get_num_args(); ++i) {
bindings.push_back(n->get_arg(i)->get_expr()); bindings.push_back(n->get_arg(i)->get_app());
} }
unsigned base_id = m.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; unsigned i = 0;
for (func_decl * acc : accessors) { for (func_decl * acc : accessors) {
app_ref acc_app(m.mk_app(acc, n->get_expr()), m); app_ref acc_app(m.mk_app(acc, n->get_app()), m);
enode * arg = n->get_arg(i); enode * arg = n->get_arg(i);
std::function<void(void)> fn = [&]() { std::function<void(void)> fn = [&]() {
@ -223,7 +223,7 @@ namespace smt {
void theory_datatype::assert_update_field_axioms(enode * n) { void theory_datatype::assert_update_field_axioms(enode * n) {
m_stats.m_assert_update_field++; m_stats.m_assert_update_field++;
SASSERT(is_update_field(n)); SASSERT(is_update_field(n));
app* own = n->get_expr(); app* own = n->get_app();
expr* arg1 = own->get_arg(0); expr* arg1 = own->get_arg(0);
func_decl * upd = n->get_decl(); func_decl * upd = n->get_decl();
func_decl * acc = to_func_decl(upd->get_parameter(0).get_ast()); func_decl * acc = to_func_decl(upd->get_parameter(0).get_ast());
@ -267,7 +267,7 @@ namespace smt {
func_decl * sub_decl = m_util.get_datatype_subterm(s); func_decl * sub_decl = m_util.get_datatype_subterm(s);
if (sub_decl) { if (sub_decl) {
TRACE(datatype, tout << "asserting reflexivity for #" << n->get_owner_id() << " " << mk_pp(n->get_expr(), m) << "\n";); TRACE(datatype, tout << "asserting reflexivity for #" << n->get_owner_id() << " " << mk_pp(n->get_expr(), m) << "\n";);
app_ref reflex(m.mk_app(sub_decl, n->get_expr(), n->get_expr()), m); app_ref reflex(m.mk_app(sub_decl, n->get_app(), n->get_app()), m);
ctx.internalize(reflex, false); ctx.internalize(reflex, false);
literal l(ctx.get_bool_var(reflex)); literal l(ctx.get_bool_var(reflex));
ctx.mark_as_relevant(l); ctx.mark_as_relevant(l);
@ -356,7 +356,7 @@ namespace smt {
sort * s = arg->get_sort(); sort * s = arg->get_sort();
sort *e_sort = nullptr; sort *e_sort = nullptr;
if (m_autil.is_array(s) && m_util.is_datatype(get_array_range(s))) { if (m_autil.is_array(s) && m_util.is_datatype(get_array_range(s))) {
app_ref def(m_autil.mk_default(arg->get_expr()), m); app_ref def(m_autil.mk_default(arg->get_app()), m);
if (!ctx.e_internalized(def)) { if (!ctx.e_internalized(def)) {
ctx.internalize(def, false); ctx.internalize(def, false);
} }
@ -542,7 +542,7 @@ namespace smt {
ptr_vector<enode> candidates = list_subterms(arg2); ptr_vector<enode> candidates = list_subterms(arg2);
for (enode *s : candidates) { for (enode *s : candidates) {
bool is_leaf = !m_util.is_constructor(s->get_expr()); bool is_leaf = !m_util.is_constructor(s->get_app());
// Case 1: Equality check (arg1 == s) // Case 1: Equality check (arg1 == s)
// Valid if sorts are compatible. // Valid if sorts are compatible.
@ -570,7 +570,7 @@ namespace smt {
if (sub_decl) { if (sub_decl) {
TRACE(datatype, tout << "adding recursive case: " << mk_pp(arg1->get_expr(), m) << " ⊑ " TRACE(datatype, tout << "adding recursive case: " << mk_pp(arg1->get_expr(), m) << " ⊑ "
<< mk_pp(s->get_expr(), m) << "\n";); << mk_pp(s->get_expr(), m) << "\n";);
auto tmp = m.mk_not(m.mk_app(sub_decl, arg1->get_expr(), s->get_expr())); auto tmp = m.mk_not(m.mk_app(sub_decl, arg1->get_app(), s->get_app()));
lits.push_back(mk_literal(tmp)); lits.push_back(mk_literal(tmp));
found_possible = true; found_possible = true;
} }
@ -617,7 +617,7 @@ namespace smt {
ptr_vector<enode> candidates = list_subterms(arg2); ptr_vector<enode> candidates = list_subterms(arg2);
for (enode *s : candidates) { for (enode *s : candidates) {
bool is_leaf = !m_util.is_constructor(s->get_expr()); bool is_leaf = !m_util.is_constructor(s->get_app());
if (s->get_sort() == arg1->get_sort()) { if (s->get_sort() == arg1->get_sort()) {
TRACE(datatype, TRACE(datatype,
@ -638,7 +638,7 @@ namespace smt {
if (sub_decl) { if (sub_decl) {
TRACE(datatype, tout << "asserting NOT " << mk_pp(arg1->get_expr(), m) << " subterm " TRACE(datatype, tout << "asserting NOT " << mk_pp(arg1->get_expr(), m) << " subterm "
<< mk_pp(s->get_expr(), m) << "\n";); << mk_pp(s->get_expr(), m) << "\n";);
auto sub_app = m.mk_app(sub_decl, arg1->get_expr(), s->get_expr()); auto sub_app = m.mk_app(sub_decl, arg1->get_app(), s->get_app());
literal sub_lit = mk_literal(sub_app); literal sub_lit = mk_literal(sub_app);
literal lits[2] = {antecedent, ~sub_lit}; literal lits[2] = {antecedent, ~sub_lit};
ctx.mk_th_axiom(get_id(), 2, lits); ctx.mk_th_axiom(get_id(), 2, lits);
@ -678,7 +678,7 @@ namespace smt {
enode *ctor = nullptr; enode *ctor = nullptr;
enode *iter = root; enode *iter = root;
do { do {
if (f.th.m_util.is_constructor(iter->get_expr())) { if (f.th.m_util.is_constructor(iter->get_app())) {
ctor = iter; ctor = iter;
break; break;
} }
@ -706,7 +706,7 @@ namespace smt {
return result; return result;
} }
void theory_datatype::relevant_eh(app * n) { void theory_datatype::relevant_eh(expr * n) {
force_push(); force_push();
TRACE(datatype, tout << "relevant_eh: " << mk_pp(n, m) << "\n";); TRACE(datatype, tout << "relevant_eh: " << mk_pp(n, m) << "\n";);
SASSERT(ctx.relevancy()); SASSERT(ctx.relevancy());
@ -967,7 +967,7 @@ namespace smt {
}; };
for (enode* sib : *n) { for (enode* sib : *n) {
if (m_sutil.str.is_concat_of_units(sib->get_expr())) { if (m_sutil.str.is_concat_of_units(sib->get_app())) {
add_todo(sib); add_todo(sib);
sibling = sib; sibling = sib;
break; break;
@ -994,7 +994,7 @@ namespace smt {
theory_array* th = dynamic_cast<theory_array*>(ctx.get_theory(m_autil.get_family_id())); theory_array* th = dynamic_cast<theory_array*>(ctx.get_theory(m_autil.get_family_id()));
for (enode* p : th->parent_selects(n)) for (enode* p : th->parent_selects(n))
m_args.push_back(p); m_args.push_back(p);
app_ref def(m_autil.mk_default(n->get_expr()), m); app_ref def(m_autil.mk_default(n->get_app()), m);
m_args.push_back(ctx.get_enode(def)); m_args.push_back(ctx.get_enode(def));
return m_args; return m_args;
} }
@ -1328,7 +1328,7 @@ namespace smt {
if (!r) { if (!r) {
ptr_vector<func_decl> const & constructors = *m_util.get_datatype_constructors(dt); ptr_vector<func_decl> const & constructors = *m_util.get_datatype_constructors(dt);
func_decl * rec = m_util.get_constructor_is(constructors[unassigned_idx]); func_decl * rec = m_util.get_constructor_is(constructors[unassigned_idx]);
auto rec_app = m.mk_app(rec, n->get_expr()); auto rec_app = m.mk_app(rec, n->get_app());
consequent = mk_literal(rec_app); consequent = mk_literal(rec_app);
} }
else { else {
@ -1405,7 +1405,7 @@ namespace smt {
} }
} }
SASSERT(r != nullptr); SASSERT(r != nullptr);
app_ref r_app(m.mk_app(r, n->get_expr()), m); app_ref r_app(m.mk_app(r, n->get_app()), m);
TRACE(datatype, tout << "creating split: " << mk_pp(r_app, m) << "\n";); TRACE(datatype, tout << "creating split: " << mk_pp(r_app, m) << "\n";);
ctx.internalize(r_app, false); ctx.internalize(r_app, false);
bool_var bv = ctx.get_bool_var(r_app); bool_var bv = ctx.get_bool_var(r_app);

14
src/smt/theory_datatype.h
View file

@ -68,17 +68,17 @@ namespace smt {
datatype_factory * m_factory; datatype_factory * m_factory;
stats m_stats; stats m_stats;
bool is_constructor(app * f) const { return m_util.is_constructor(f); } bool is_constructor(expr * f) const { return m_util.is_constructor(f); }
bool is_recognizer(app * f) const { return m_util.is_recognizer(f); } bool is_recognizer(expr * f) const { return m_util.is_recognizer(f); }
bool is_subterm_predicate(app * f) const { return m_util.is_subterm_predicate(f); } bool is_subterm_predicate(expr * f) const { return m_util.is_subterm_predicate(f); }
bool is_accessor(app * f) const { return m_util.is_accessor(f); } bool is_accessor(expr * f) const { return m_util.is_accessor(f); }
bool is_update_field(app * f) const { return m_util.is_update_field(f); } bool is_update_field(expr * f) const { return m_util.is_update_field(f); }
bool is_constructor(enode * n) const { return is_constructor(n->get_expr()); } bool is_constructor(enode * n) const { return is_constructor(n->get_expr()); }
bool is_recognizer(enode * n) const { return is_recognizer(n->get_expr()); } bool is_recognizer(enode * n) const { return is_recognizer(n->get_expr()); }
bool is_subterm_predicate(enode * n) const { return is_subterm_predicate(n->get_expr()); } bool is_subterm_predicate(enode * n) const { return is_subterm_predicate(n->get_expr()); }
bool is_accessor(enode * n) const { return is_accessor(n->get_expr()); } bool is_accessor(enode * n) const { return is_accessor(n->get_expr()); }
bool is_update_field(enode * n) const { return m_util.is_update_field(n->get_expr()); } bool is_update_field(enode * n) const { return is_update_field(n->get_expr()); }
void assert_eq_axiom(enode * lhs, expr * rhs, literal antecedent); void assert_eq_axiom(enode * lhs, expr * rhs, literal antecedent);
void assert_is_constructor_axiom(enode * n, func_decl * c, literal antecedent); void assert_is_constructor_axiom(enode * n, func_decl * c, literal antecedent);
@ -148,7 +148,7 @@ namespace smt {
bool use_diseqs() const override; bool use_diseqs() const override;
void new_diseq_eh(theory_var v1, theory_var v2) override; void new_diseq_eh(theory_var v1, theory_var v2) override;
void assign_eh(bool_var v, bool is_true) override; void assign_eh(bool_var v, bool is_true) override;
void relevant_eh(app * n) override; void relevant_eh(expr * n) override;
void push_scope_eh() override; void push_scope_eh() override;
void pop_scope_eh(unsigned num_scopes) override; void pop_scope_eh(unsigned num_scopes) override;
final_check_status final_check_eh(unsigned) override; final_check_status final_check_eh(unsigned) override;

8
src/smt/theory_dense_diff_logic_def.h
View file

@ -721,7 +721,7 @@ namespace smt {
TRACE(ddl_model, TRACE(ddl_model,
tout << "ddl model\n"; tout << "ddl model\n";
for (theory_var v = 0; v < num_vars; ++v) { for (theory_var v = 0; v < num_vars; ++v) {
tout << "#" << mk_pp(get_enode(v)->get_expr(), m) << " = " << m_assignment[v] << "\n"; tout << "#" << mk_pp(get_expr(v), m) << " = " << m_assignment[v] << "\n";
}); });
} }
@ -799,11 +799,11 @@ namespace smt {
enode * n = get_enode(v); enode * n = get_enode(v);
if (m_autil.is_zero(n->get_expr()) && !m_assignment[v].is_zero()) { if (m_autil.is_zero(n->get_expr()) && !m_assignment[v].is_zero()) {
numeral val = m_assignment[v]; numeral val = m_assignment[v];
sort * s = n->get_expr()->get_sort(); sort * s = n->get_sort();
// adjust the value of all variables that have the same sort. // adjust the value of all variables that have the same sort.
for (int v2 = 0; v2 < num_vars; ++v2) { for (int v2 = 0; v2 < num_vars; ++v2) {
enode * n2 = get_enode(v2); enode * n2 = get_enode(v2);
if (n2->get_expr()->get_sort() == s) { if (n2->get_sort() == s) {
m_assignment[v2] -= val; m_assignment[v2] -= val;
} }
} }
@ -813,7 +813,7 @@ namespace smt {
TRACE(ddl_model, TRACE(ddl_model,
tout << "ddl model\n"; tout << "ddl model\n";
for (theory_var v = 0; v < num_vars; ++v) { for (theory_var v = 0; v < num_vars; ++v) {
tout << "#" << mk_pp(get_enode(v)->get_expr(), m) << " = " << m_assignment[v] << "\n"; tout << "#" << mk_pp(get_expr(v), m) << " = " << m_assignment[v] << "\n";
}); });
} }

2
src/smt/theory_diff_logic.h
View file

@ -263,7 +263,7 @@ namespace smt {
m_arith_eq_adapter.restart_eh(); m_arith_eq_adapter.restart_eh();
} }
void relevant_eh(app* e) override {} void relevant_eh(expr* e) override {}
void init_search_eh() override { void init_search_eh() override {
m_arith_eq_adapter.init_search_eh(); m_arith_eq_adapter.init_search_eh();

8
src/smt/theory_diff_logic_def.h
View file

@ -384,7 +384,7 @@ final_check_status theory_diff_logic<Ext>::final_check_eh(unsigned level) {
} }
for (enode* n : ctx.enodes()) { for (enode* n : ctx.enodes()) {
family_id fid = n->get_expr()->get_family_id(); family_id fid = n->get_family_id();
if (fid != get_family_id() && if (fid != get_family_id() &&
fid != m.get_basic_family_id() && fid != m.get_basic_family_id() &&
!is_uninterp_const(n->get_expr())) { !is_uninterp_const(n->get_expr())) {
@ -974,7 +974,7 @@ theory_var theory_diff_logic<Ext>::expand(bool pos, theory_var v, rational & k)
enode* e = get_enode(v); enode* e = get_enode(v);
rational r; rational r;
for (;;) { for (;;) {
app* n = e->get_expr(); app* n = e->get_app();
if (m_util.is_add(n) && n->get_num_args() == 2) { if (m_util.is_add(n) && n->get_num_args() == 2) {
app* x = to_app(n->get_arg(0)); app* x = to_app(n->get_arg(0));
app* y = to_app(n->get_arg(1)); app* y = to_app(n->get_arg(1));
@ -1024,8 +1024,8 @@ void theory_diff_logic<Ext>::new_eq_or_diseq(bool is_eq, theory_var v1, theory_v
app_ref eq(m), s2(m), t2(m); app_ref eq(m), s2(m), t2(m);
app* s1 = get_enode(s)->get_expr(); expr* s1 = get_expr(s);
app* t1 = get_enode(t)->get_expr(); expr* t1 = get_expr(t);
s2 = m_util.mk_sub(t1, s1); s2 = m_util.mk_sub(t1, s1);
t2 = m_util.mk_numeral(k, s2->get_sort()); t2 = m_util.mk_numeral(k, s2->get_sort());
// t1 - s1 = k // t1 - s1 = k

6
src/smt/theory_dl.cpp
View file

@ -166,20 +166,20 @@ namespace smt {
} }
void apply_sort_cnstr(enode * n, sort * s) override { void apply_sort_cnstr(enode * n, sort * s) override {
app* term = n->get_expr(); auto term = n->get_app();
if (u().is_finite_sort(term)) { if (u().is_finite_sort(term)) {
mk_rep(term); mk_rep(term);
} }
} }
void relevant_eh(app * n) override { void relevant_eh(expr * n) override {
if (u().is_finite_sort(n)) { if (u().is_finite_sort(n)) {
sort* s = n->get_sort(); sort* s = n->get_sort();
func_decl* r, *v; func_decl* r, *v;
get_rep(s, r, v); get_rep(s, r, v);
if (n->get_decl() != v) { if (is_app(n) && to_app(n)->get_decl() != v) {
expr* rep = m().mk_app(r, n); expr* rep = m().mk_app(r, n);
uint64_t vl; uint64_t vl;
if (u().is_numeral_ext(n, vl)) { if (u().is_numeral_ext(n, vl)) {

5
src/smt/theory_finite_set.cpp
View file

@ -239,8 +239,9 @@ namespace smt {
return true; return true;
} }
void theory_finite_set::relevant_eh(app* t) { void theory_finite_set::relevant_eh(expr* t) {
add_immediate_axioms(t); if (is_app(t))
add_immediate_axioms(to_app(t));
} }
void theory_finite_set::apply_sort_cnstr(enode* n, sort* s) { void theory_finite_set::apply_sort_cnstr(enode* n, sort* s) {

2
src/smt/theory_finite_set.h
View file

@ -155,7 +155,7 @@ namespace smt {
bool can_propagate() override; bool can_propagate() override;
void propagate() override; void propagate() override;
void assign_eh(bool_var v, bool is_true) override; void assign_eh(bool_var v, bool is_true) override;
void relevant_eh(app *n) override; void relevant_eh(expr *n) override;
theory * mk_fresh(context * new_ctx) override; theory * mk_fresh(context * new_ctx) override;
char const * get_name() const override { return "finite_set"; } char const * get_name() const override { return "finite_set"; }

10
src/smt/theory_fpa.cpp
View file

@ -298,9 +298,9 @@ namespace smt {
SASSERT(s->get_family_id() == get_family_id()); 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(s) || m_fpa_util.is_rm(s));
SASSERT(m_fpa_util.is_float(n->get_expr()) || m_fpa_util.is_rm(n->get_expr())); SASSERT(m_fpa_util.is_float(n->get_expr()) || m_fpa_util.is_rm(n->get_expr()));
SASSERT(n->get_expr()->get_decl()->get_range() == s); SASSERT(n->get_decl()->get_range() == s);
app * owner = n->get_expr(); expr * owner = n->get_expr();
if (!is_attached_to_var(n)) { if (!is_attached_to_var(n)) {
attach_new_th_var(n); attach_new_th_var(n);
@ -437,7 +437,7 @@ namespace smt {
assert_cnstr(cnstr); assert_cnstr(cnstr);
} }
void theory_fpa::relevant_eh(app * n) { void theory_fpa::relevant_eh(expr * n) {
TRACE(t_fpa, tout << "relevant_eh for: " << mk_ismt2_pp(n, m) << "\n";); TRACE(t_fpa, tout << "relevant_eh for: " << mk_ismt2_pp(n, m) << "\n";);
mpf_manager & mpfm = m_fpa_util.fm(); mpf_manager & mpfm = m_fpa_util.fm();
@ -477,7 +477,7 @@ namespace smt {
// get-fp), mk_uf creates a separate BV UF that is not // get-fp), mk_uf creates a separate BV UF that is not
// linked to bvwrap. Assert wrap(n) == concat(conv_components) // linked to bvwrap. Assert wrap(n) == concat(conv_components)
// to close the constraint gap (same pattern as numerals above). // to close the constraint gap (same pattern as numerals above).
if (n->get_family_id() != get_family_id()) { if (!is_app(n) || to_app(n)->get_family_id() != get_family_id()) {
expr_ref conv_e = convert(n); expr_ref conv_e = convert(n);
if (m_fpa_util.is_fp(conv_e) && to_app(conv_e)->get_num_args() == 3) { if (m_fpa_util.is_fp(conv_e) && to_app(conv_e)->get_num_args() == 3) {
app_ref conv_a(m); app_ref conv_a(m);
@ -491,7 +491,7 @@ namespace smt {
} }
} }
} }
else if (n->get_family_id() == get_family_id()) { else if (is_app(n) && to_app(n)->get_family_id() == get_family_id()) {
// These are the conversion functions fp.to_* */ // These are the conversion functions fp.to_* */
SASSERT(!m_fpa_util.is_float(n) && !m_fpa_util.is_rm(n)); SASSERT(!m_fpa_util.is_float(n) && !m_fpa_util.is_rm(n));
} }

2
src/smt/theory_fpa.h
View file

@ -104,7 +104,7 @@ namespace smt {
model_value_proc * mk_value(enode * n, model_generator & mg) override; model_value_proc * mk_value(enode * n, model_generator & mg) override;
void assign_eh(bool_var v, bool is_true) override; void assign_eh(bool_var v, bool is_true) override;
void relevant_eh(app * n) override; void relevant_eh(expr * n) override;
void init_model(model_generator & m) override; void init_model(model_generator & m) override;
void finalize_model(model_generator & mg) override; void finalize_model(model_generator & mg) override;

2
src/smt/theory_intblast.cpp
View file

@ -153,7 +153,7 @@ namespace smt {
void theory_intblast::apply_sort_cnstr(enode* n, sort* s) { void theory_intblast::apply_sort_cnstr(enode* n, sort* s) {
SASSERT(bv.is_bv_sort(s)); SASSERT(bv.is_bv_sort(s));
if (!is_attached_to_var(n)) { if (!is_attached_to_var(n)) {
m_translator.internalize_bv(n->get_expr()); m_translator.internalize_bv(n->get_app());
auto v = mk_var(n); auto v = mk_var(n);
ctx.attach_th_var(n, this, v); ctx.attach_th_var(n, this, v);
} }

35
src/smt/theory_lra.cpp
View file

@ -228,7 +228,7 @@ class theory_lra::imp {
bool is_real(enode* n) const { return a.is_real(n->get_expr()); } bool is_real(enode* n) const { return a.is_real(n->get_expr()); }
enode* get_enode(theory_var v) const { return th.get_enode(v); } enode* get_enode(theory_var v) const { return th.get_enode(v); }
enode* get_enode(expr* e) const { return ctx().get_enode(e); } enode* get_enode(expr* e) const { return ctx().get_enode(e); }
expr* get_owner(theory_var v) const { return get_enode(v)->get_expr(); } expr* get_expr(theory_var v) const { return get_enode(v)->get_expr(); }
enode_pp pp(enode* n) const { return enode_pp(n, ctx()); } enode_pp pp(enode* n) const { return enode_pp(n, ctx()); }
enode_pp pp(theory_var v) const { return pp(get_enode(v)); } enode_pp pp(theory_var v) const { return pp(get_enode(v)); }
mk_bounded_pp bpp(expr* e) { return mk_bounded_pp(e, m); } mk_bounded_pp bpp(expr* e) { return mk_bounded_pp(e, m); }
@ -1118,7 +1118,7 @@ public:
m_nla->simplify(); m_nla->simplify();
} }
void relevant_eh(app* n) { void relevant_eh(expr* n) {
expr* n1, *n2; expr* n1, *n2;
if (a.is_mod(n, n1, n2)) if (a.is_mod(n, n1, n2))
mk_idiv_mod_axioms(n1, n2); mk_idiv_mod_axioms(n1, n2);
@ -1127,11 +1127,11 @@ public:
else if (a.is_div(n, n1, n2)) else if (a.is_div(n, n1, n2))
mk_div_axiom(n1, n2); mk_div_axiom(n1, n2);
else if (a.is_to_int(n)) else if (a.is_to_int(n))
mk_to_int_axiom(n); mk_to_int_axiom(to_app(n));
else if (a.is_is_int(n)) else if (a.is_is_int(n))
mk_is_int_axiom(n); mk_is_int_axiom(to_app(n));
else if (m.is_ite(n)) else if (m.is_ite(n))
mk_ite_axiom(n); mk_ite_axiom(to_app(n));
else if (a.is_power(n, n1, n2)) else if (a.is_power(n, n1, n2))
mk_power_axiom(n, n1, n2); mk_power_axiom(n, n1, n2);
} }
@ -1252,9 +1252,9 @@ public:
/// abs(r) > r >= 0 /// abs(r) > r >= 0
void assert_idiv_mod_axioms(theory_var u, theory_var v, theory_var w, rational const& r) { void assert_idiv_mod_axioms(theory_var u, theory_var v, theory_var w, rational const& r) {
app_ref term(m); app_ref term(m);
term = a.mk_mul(a.mk_numeral(r, true), get_enode(w)->get_expr()); term = a.mk_mul(a.mk_numeral(r, true), get_expr(w));
term = a.mk_add(get_enode(v)->get_expr(), term); term = a.mk_add(get_expr(v), term);
term = a.mk_sub(get_enode(u)->get_expr(), term); term = a.mk_sub(get_expr(u), term);
theory_var z = internalize_def(term); theory_var z = internalize_def(term);
lpvar zi = register_theory_var_in_lar_solver(z); lpvar zi = register_theory_var_in_lar_solver(z);
lpvar vi = register_theory_var_in_lar_solver(v); lpvar vi = register_theory_var_in_lar_solver(v);
@ -1837,7 +1837,7 @@ public:
rational lc = denominator(k); rational lc = denominator(k);
for (auto const& kv : coeffs) { for (auto const& kv : coeffs) {
theory_var w = kv.m_key; theory_var w = kv.m_key;
expr* o = get_enode(w)->get_expr(); expr* o = get_expr(w);
is_int = a.is_int(o); is_int = a.is_int(o);
if (!is_int) break; if (!is_int) break;
lc = lcm(lc, denominator(kv.m_value)); lc = lcm(lc, denominator(kv.m_value));
@ -2512,7 +2512,7 @@ public:
lpvar vi = be.m_j; lpvar vi = be.m_j;
if (lp().column_has_term(vi)) if (lp().column_has_term(vi))
return; return;
expr_ref w(get_enode(v)->get_expr(), m); expr_ref w(get_expr(v), m);
if (a.is_add(w) || a.is_numeral(w) || m.is_ite(w)) if (a.is_add(w) || a.is_numeral(w) || m.is_ite(w))
return; return;
literal bound = null_literal; literal bound = null_literal;
@ -3417,7 +3417,7 @@ public:
theory_var v = lp().local_to_external(vi); theory_var v = lp().local_to_external(vi);
rational val; rational val;
TRACE(arith, tout << lp().get_variable_name(vi) << " " << v << "\n";); TRACE(arith, tout << lp().get_variable_name(vi) << " " << v << "\n";);
if (v != null_theory_var && a.is_numeral(get_owner(v), val) && bound == val) { if (v != null_theory_var && a.is_numeral(get_expr(v), val) && bound == val) {
dep = nullptr; dep = nullptr;
return bound == val; return bound == val;
} }
@ -4131,7 +4131,7 @@ public:
// Overload: create blocker from a saved impq value (used when x has been restored) // Overload: create blocker from a saved impq value (used when x has been restored)
expr_ref mk_gt(theory_var v, lp::impq const& val) { expr_ref mk_gt(theory_var v, lp::impq const& val) {
expr* obj = get_enode(v)->get_expr(); expr* obj = get_expr(v);
rational r = val.x; rational r = val.x;
expr_ref e(m); expr_ref e(m);
if (a.is_int(obj->get_sort())) { if (a.is_int(obj->get_sort())) {
@ -4189,7 +4189,7 @@ public:
app_ref coeffs2app(u_map<rational> const& coeffs, rational const& offset, bool is_int) { app_ref coeffs2app(u_map<rational> const& coeffs, rational const& offset, bool is_int) {
expr_ref_vector args(m); expr_ref_vector args(m);
for (auto const& [w, coeff] : coeffs) { for (auto const& [w, coeff] : coeffs) {
expr* o = get_enode(w)->get_expr(); expr* o = get_expr(w);
if (coeff.is_zero()) { if (coeff.is_zero()) {
// continue // continue
} }
@ -4236,13 +4236,14 @@ public:
app_ref mk_obj(theory_var v) { app_ref mk_obj(theory_var v) {
auto t = get_lpvar(v); auto t = get_lpvar(v);
bool is_int = a.is_int(get_enode(v)->get_expr()); auto e = th.get_expr(v);
bool is_int = a.is_int(e);
if (lp().column_has_term(t)) { if (lp().column_has_term(t)) {
return mk_term(lp().get_term(t), is_int); return mk_term(lp().get_term(t), is_int);
} }
else { else {
// theory_var w = lp().external_to_local(vi); // theory_var w = lp().external_to_local(vi);
return app_ref(get_enode(v)->get_expr(), m); return app_ref(to_app(e), m);
} }
} }
@ -4250,7 +4251,7 @@ public:
rational r = val.get_rational(); rational r = val.get_rational();
bool is_strict = val.get_infinitesimal().is_pos(); bool is_strict = val.get_infinitesimal().is_pos();
app_ref b(m); app_ref b(m);
bool is_int = a.is_int(get_enode(v)->get_expr()); bool is_int = a.is_int(get_expr(v));
TRACE(arith, display(tout << "v" << v << "\n");); TRACE(arith, display(tout << "v" << v << "\n"););
if (is_strict) { if (is_strict) {
b = a.mk_le(mk_obj(v), a.mk_numeral(r, is_int)); b = a.mk_le(mk_obj(v), a.mk_numeral(r, is_int));
@ -4456,7 +4457,7 @@ void theory_lra::pop_scope_eh(unsigned num_scopes) {
void theory_lra::restart_eh() { void theory_lra::restart_eh() {
m_imp->restart_eh(); m_imp->restart_eh();
} }
void theory_lra::relevant_eh(app* e) { void theory_lra::relevant_eh(expr* e) {
m_imp->relevant_eh(e); m_imp->relevant_eh(e);
} }
void theory_lra::init_search_eh() { void theory_lra::init_search_eh() {

2
src/smt/theory_lra.h
View file

@ -59,7 +59,7 @@ namespace smt {
void restart_eh() override; void restart_eh() override;
void relevant_eh(app* e) override; void relevant_eh(expr* e) override;
void init_search_eh() override; void init_search_eh() override;

2
src/smt/theory_pb.cpp
View file

@ -2367,7 +2367,7 @@ namespace smt {
} }
model_value_proc * theory_pb::mk_value(enode * n, model_generator & mg) { model_value_proc * theory_pb::mk_value(enode * n, model_generator & mg) {
app* a = n->get_expr(); auto a = n->get_app();
pb_model_value_proc* p = alloc(pb_model_value_proc, a); pb_model_value_proc* p = alloc(pb_model_value_proc, a);
for (unsigned i = 0; i < a->get_num_args(); ++i) { for (unsigned i = 0; i < a->get_num_args(); ++i) {
p->add(ctx.get_enode(a->get_arg(i))); p->add(ctx.get_enode(a->get_arg(i)));

2
src/smt/theory_recfun.cpp
View file

@ -99,7 +99,7 @@ namespace smt {
* then case-expand `n`. If it's a macro we can also immediately * then case-expand `n`. If it's a macro we can also immediately
* body-expand it. * body-expand it.
*/ */
void theory_recfun::relevant_eh(app * n) { void theory_recfun::relevant_eh(expr * n) {
SASSERT(ctx.relevancy()); SASSERT(ctx.relevancy());
// TRACEFN("relevant_eh: (defined) " << u().is_defined(n) << " " << mk_pp(n, m)); // TRACEFN("relevant_eh: (defined) " << u().is_defined(n) << " " << mk_pp(n, m));
if (u().is_defined(n) && u().has_defs()) if (u().is_defined(n) && u().has_defs())

6
src/smt/theory_recfun.h
View file

@ -61,8 +61,8 @@ namespace smt {
bool is_disabled_guard(expr* guard) { return m_disabled_guards.contains(guard); } bool is_disabled_guard(expr* guard) { return m_disabled_guards.contains(guard); }
recfun::util & u() const { return m_util; } recfun::util & u() const { return m_util; }
bool is_defined(app * f) const { return u().is_defined(f); } bool is_defined(expr * f) const { return u().is_defined(f); }
bool is_case_pred(app * f) const { return u().is_case_pred(f); } bool is_case_pred(expr * f) const { return u().is_case_pred(f); }
bool is_defined(enode * e) const { return is_defined(e->get_expr()); } bool is_defined(enode * e) const { return is_defined(e->get_expr()); }
bool is_case_pred(enode * e) const { return is_case_pred(e->get_expr()); } bool is_case_pred(enode * e) const { return is_case_pred(e->get_expr()); }
@ -90,7 +90,7 @@ namespace smt {
bool internalize_atom(app * atom, bool gate_ctx) override; bool internalize_atom(app * atom, bool gate_ctx) override;
bool internalize_term(app * term) override; bool internalize_term(app * term) override;
void reset_eh() override; void reset_eh() override;
void relevant_eh(app * n) override; void relevant_eh(expr * n) override;
char const * get_name() const override; char const * get_name() const override;
final_check_status final_check_eh(unsigned) override; final_check_status final_check_eh(unsigned) override;
void assign_eh(bool_var v, bool is_true) override; void assign_eh(bool_var v, bool is_true) override;

9
src/smt/theory_seq.cpp
View file

@ -2103,7 +2103,7 @@ app* theory_seq::get_ite_value(expr* e) {
} }
model_value_proc * theory_seq::mk_value(enode * n, model_generator & mg) { model_value_proc * theory_seq::mk_value(enode * n, model_generator & mg) {
app* e = n->get_expr(); expr* e = n->get_expr();
TRACE(seq, tout << mk_pp(e, m) << "\n";); TRACE(seq, tout << mk_pp(e, m) << "\n";);
// Shortcut for well-founded values to avoid some quadratic overhead // Shortcut for well-founded values to avoid some quadratic overhead
@ -2163,7 +2163,7 @@ model_value_proc * theory_seq::mk_value(enode * n, model_generator & mg) {
} }
app* theory_seq::mk_value(app* e) { app* theory_seq::mk_value(expr* e) {
expr_ref result(m); expr_ref result(m);
e = get_ite_value(e); e = get_ite_value(e);
result = m_rep.find(e); result = m_rep.find(e);
@ -3286,7 +3286,10 @@ void theory_seq::pop_scope_eh(unsigned num_scopes) {
void theory_seq::restart_eh() { void theory_seq::restart_eh() {
} }
void theory_seq::relevant_eh(app* n) { void theory_seq::relevant_eh(expr* _n) {
if (!is_app(_n))
return;
app *n = to_app(_n);
if (m_util.str.is_index(n) || if (m_util.str.is_index(n) ||
m_util.str.is_replace(n) || m_util.str.is_replace(n) ||
m_util.str.is_extract(n) || m_util.str.is_extract(n) ||

4
src/smt/theory_seq.h
View file

@ -392,7 +392,7 @@ namespace smt {
void push_scope_eh() override; void push_scope_eh() override;
void pop_scope_eh(unsigned num_scopes) override; void pop_scope_eh(unsigned num_scopes) override;
void restart_eh() override; void restart_eh() override;
void relevant_eh(app* n) override; void relevant_eh(expr* n) override;
bool should_research(expr_ref_vector &) override; bool should_research(expr_ref_vector &) override;
void add_theory_assumptions(expr_ref_vector & assumptions) override; void add_theory_assumptions(expr_ref_vector & assumptions) override;
theory* mk_fresh(context* new_ctx) override { return alloc(theory_seq, *new_ctx); } theory* mk_fresh(context* new_ctx) override { return alloc(theory_seq, *new_ctx); }
@ -629,7 +629,7 @@ namespace smt {
void init() override; void init() override;
// model building // model building
app* mk_value(app* a); app* mk_value(expr* a);
trail_stack& get_trail_stack() { return m_trail_stack; } trail_stack& get_trail_stack() { return m_trail_stack; }
void merge_eh(theory_var, theory_var, theory_var v1, theory_var v2) {} void merge_eh(theory_var, theory_var, theory_var v1, theory_var v2) {}

4
src/smt/theory_special_relations.cpp
View file

@ -174,8 +174,8 @@ namespace smt {
} }
void theory_special_relations::new_eq_eh(theory_var v1, theory_var v2) { void theory_special_relations::new_eq_eh(theory_var v1, theory_var v2) {
app* t1 = get_expr(v1); expr* t1 = get_expr(v1);
app* t2 = get_expr(v2); expr* t2 = get_expr(v2);
literal eq = mk_eq(t1, t2, false); literal eq = mk_eq(t1, t2, false);
for (auto const& kv : m_relations) { for (auto const& kv : m_relations) {
relation& r = *kv.m_value; relation& r = *kv.m_value;

4
src/smt/theory_utvpi.h
View file

@ -239,7 +239,7 @@ namespace smt {
m_arith_eq_adapter.restart_eh(); m_arith_eq_adapter.restart_eh();
} }
void relevant_eh(app* e) override {} void relevant_eh(expr* e) override {}
void init_search_eh() override { void init_search_eh() override {
m_arith_eq_adapter.init_search_eh(); m_arith_eq_adapter.init_search_eh();
@ -323,7 +323,7 @@ namespace smt {
void new_eq_or_diseq(bool is_eq, th_var v1, th_var v2, justification& eq_just); void new_eq_or_diseq(bool is_eq, th_var v1, th_var v2, justification& eq_just);
bool is_int(theory_var v) const { return a.is_int(get_enode(v)->get_expr()); } bool is_int(theory_var v) const { return a.is_int(get_expr(v)); }
th_var get_zero(sort* s) { return a.is_int(s) ? m_izero : m_rzero; } th_var get_zero(sort* s) { return a.is_int(s) ? m_izero : m_rzero; }

8
src/smt/theory_utvpi_def.h
View file

@ -170,8 +170,8 @@ namespace smt {
// //
app_ref eq(m), s2(m), t2(m); app_ref eq(m), s2(m), t2(m);
app* s1 = get_enode(s)->get_expr(); expr* s1 = get_expr(s);
app* t1 = get_enode(t)->get_expr(); expr* t1 = get_expr(t);
s2 = a.mk_sub(t1, s1); s2 = a.mk_sub(t1, s1);
t2 = a.mk_numeral(k, s2->get_sort()); t2 = a.mk_numeral(k, s2->get_sort());
eq = m.mk_eq(s2.get(), t2.get()); eq = m.mk_eq(s2.get(), t2.get());
@ -588,7 +588,7 @@ namespace smt {
expr* x, *y; expr* x, *y;
rational r; rational r;
for (;;) { for (;;) {
app* n = e->get_expr(); auto n = e->get_expr();
if (a.is_add(n, x, y)) { if (a.is_add(n, x, y)) {
if (a.is_numeral(x, r)) { if (a.is_numeral(x, r)) {
e = ctx.get_enode(y); e = ctx.get_enode(y);
@ -906,7 +906,7 @@ namespace smt {
num = num/rational(2); num = num/rational(2);
SASSERT(!is_int || num.is_int()); SASSERT(!is_int || num.is_int());
TRACE(utvpi, TRACE(utvpi,
expr* n = get_enode(v)->get_expr(); expr* n = get_expr(v);
tout << mk_pp(n, m) << " |-> (" << val1 << " - " << val2 << ")/2 = " << num << "\n";); tout << mk_pp(n, m) << " |-> (" << val1 << " - " << val2 << ")/2 = " << num << "\n";);
return num; return num;