mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-04-23 09:05:31 +00:00
Code Activity

streamline pb solver interface and naming after removal of xor

Browse source
This commit is contained in:
Nikolaj Bjorner 2021-02-28 12:32:04 -08:00
parent 13f05ae9dc
commit 026065ff71
73 changed files with 1131 additions and 1201 deletions
Download patch file Download diff file Expand all files Collapse all files

22
src/smt/arith_eq_adapter.cpp
View file

@ -86,11 +86,11 @@ namespace smt {
return;
ast_manager & m = get_manager();
TRACE("arith_eq_adapter_mk_axioms", tout << "#" << n1->get_owner_id() << " #" << n2->get_owner_id() << "\n";
tout << mk_ismt2_pp(n1->get_owner(), m) << "\n" << mk_ismt2_pp(n2->get_owner(), 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())
std::swap(n1, n2);
app * t1 = n1->get_owner();
app * t2 = n2->get_owner();
app * t1 = n1->get_expr();
app * t2 = n2->get_expr();
if (m.are_distinct(t1, t2)) {
expr_ref eq(m.mk_eq(t1, t2), m);
ctx.internalize(eq, true);
@ -110,8 +110,8 @@ namespace smt {
CTRACE("arith_eq_adapter_relevancy", !(ctx.is_relevant(n1) && ctx.is_relevant(n2)),
tout << "is_relevant(n1): #" << n1->get_owner_id() << " " << ctx.is_relevant(n1) << "\n";
tout << "is_relevant(n2): #" << n2->get_owner_id() << " " << ctx.is_relevant(n2) << "\n";
tout << mk_pp(n1->get_owner(), get_manager()) << "\n";
tout << mk_pp(n2->get_owner(), get_manager()) << "\n";
tout << pp(n1, get_manager()) << "\n";
tout << pp(n2, get_manager()) << "\n";
ctx.display(tout););
//
// The atoms d.m_t1_eq_t2, d.m_le, and d.m_ge should only be marked as relevant
@ -127,8 +127,8 @@ namespace smt {
m_stats.m_num_eq_axioms++;
TRACE("arith_eq_adapter_profile_detail",
tout << "mk_detail " << mk_bounded_pp(n1->get_owner(), m, 5) << " " <<
mk_bounded_pp(n2->get_owner(), m, 5) << "\n";);
tout << "mk_detail " << mk_bounded_pp(n1->get_expr(), m, 5) << " " <<
mk_bounded_pp(n2->get_expr(), m, 5) << "\n";);
app_ref t1_eq_t2(m);
t1_eq_t2 = ctx.mk_eq_atom(t1, t2);
@ -222,9 +222,9 @@ namespace smt {
ctx.mk_th_axiom(tid, le_lit, ge_lit, m_proof_hint.size(), m_proof_hint.c_ptr());
}
if (ctx.relevancy()) {
relevancy_eh * eh = ctx.mk_relevancy_eh(arith_eq_relevancy_eh(n1->get_owner(), n2->get_owner(), t1_eq_t2, le, ge));
ctx.add_relevancy_eh(n1->get_owner(), eh);
ctx.add_relevancy_eh(n2->get_owner(), eh);
relevancy_eh * eh = ctx.mk_relevancy_eh(arith_eq_relevancy_eh(n1->get_expr(), n2->get_expr(), t1_eq_t2, le, ge));
ctx.add_relevancy_eh(n1->get_expr(), eh);
ctx.add_relevancy_eh(n2->get_expr(), eh);
}
if (!m_owner.get_fparams().m_arith_lazy_adapter && !ctx.at_base_level() &&
n1->get_iscope_lvl() <= ctx.get_base_level() && n2->get_iscope_lvl() <= ctx.get_base_level()) {
@ -235,7 +235,7 @@ namespace smt {
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_bug", tout << mk_bounded_pp(get_enode(v1)->get_owner(), get_manager()) << "\n" << mk_bounded_pp(get_enode(v2)->get_owner(), get_manager()) << "\n";);
TRACE("arith_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";);
mk_axioms(get_enode(v1), get_enode(v2));
}

32
src/smt/mam.cpp
View file

@ -2027,7 +2027,7 @@ namespace {
init(t);
if (t->filter_candidates()) {
for (enode* app : t->get_candidates()) {
TRACE("trigger_bug", tout << "candidate\n" << mk_ismt2_pp(app->get_owner(), m) << "\n";);
TRACE("trigger_bug", tout << "candidate\n" << mk_ismt2_pp(app->get_expr(), m) << "\n";);
if (!app->is_marked() && app->is_cgr()) {
if (m_context.resource_limits_exceeded() || !execute_core(t, app))
return;
@ -2041,7 +2041,7 @@ namespace {
}
else {
for (enode* app : t->get_candidates()) {
TRACE("trigger_bug", tout << "candidate\n" << mk_ismt2_pp(app->get_owner(), m) << "\n";);
TRACE("trigger_bug", tout << "candidate\n" << mk_ismt2_pp(app->get_expr(), m) << "\n";);
if (app->is_cgr()) {
TRACE("trigger_bug", tout << "is_cgr\n";);
if (m_context.resource_limits_exceeded() || !execute_core(t, app))
@ -2244,7 +2244,7 @@ namespace {
if (m_use_filters)
out << ", lbls: " << n->get_root()->get_lbls() << " ";
out << "\n";
out << mk_pp(n->get_owner(), m) << "\n";
out << mk_pp(n->get_expr(), m) << "\n";
}
}
@ -2287,7 +2287,7 @@ namespace {
#endif
bool interpreter::execute_core(code_tree * t, enode * n) {
TRACE("trigger_bug", tout << "interpreter::execute_core\n"; t->display(tout); tout << "\nenode\n" << mk_ismt2_pp(n->get_owner(), m) << "\n";);
TRACE("trigger_bug", tout << "interpreter::execute_core\n"; t->display(tout); tout << "\nenode\n" << mk_ismt2_pp(n->get_expr(), m) << "\n";);
unsigned since_last_check = 0;
#ifdef _PROFILE_MAM
@ -2473,7 +2473,7 @@ namespace {
m_app = get_first_f_app(static_cast<const bind *>(m_pc)->m_label, static_cast<const bind *>(m_pc)->m_num_args, m_n1); \
if (!m_app) \
goto backtrack; \
TRACE("mam_int", tout << "bind candidate: " << mk_pp(m_app->get_owner(), m) << "\n";); \
TRACE("mam_int", tout << "bind candidate: " << mk_pp(m_app->get_expr(), m) << "\n";); \
m_backtrack_stack[m_top].m_instr = m_pc; \
m_backtrack_stack[m_top].m_old_max_generation = m_curr_max_generation; \
m_backtrack_stack[m_top].m_old_used_enodes_size = m_curr_used_enodes_size; \
@ -2623,7 +2623,7 @@ namespace {
#define SET_VAR(IDX) \
m_args[IDX] = m_registers[static_cast<const get_cgr *>(m_pc)->m_iregs[IDX]]; \
if (m_use_filters && static_cast<const get_cgr *>(m_pc)->m_lbl_set.empty_intersection(m_args[IDX]->get_root()->get_plbls())) { \
TRACE("trigger_bug", tout << "m_args[IDX]->get_root():\n" << mk_ismt2_pp(m_args[IDX]->get_root()->get_owner(), m) << "\n"; \
TRACE("trigger_bug", tout << "m_args[IDX]->get_root():\n" << mk_ismt2_pp(m_args[IDX]->get_root()->get_expr(), m) << "\n"; \
tout << "cgr set: "; static_cast<const get_cgr *>(m_pc)->m_lbl_set.display(tout); tout << "\n"; \
tout << "node set: "; m_args[IDX]->get_root()->get_plbls().display(tout); tout << "\n";); \
goto backtrack; \
@ -2687,7 +2687,7 @@ namespace {
if (m_app == nullptr)
goto backtrack;
m_pattern_instances.push_back(m_app);
TRACE("mam_int", tout << "continue candidate:\n" << mk_ll_pp(m_app->get_owner(), m););
TRACE("mam_int", tout << "continue candidate:\n" << mk_ll_pp(m_app->get_expr(), m););
for (unsigned i = 0; i < m_num_args; i++)
m_registers[m_oreg+i] = m_app->get_arg(i);
m_pc = m_pc->m_next;
@ -2750,7 +2750,7 @@ namespace {
goto backtrack; \
} \
bp.m_curr = m_app; \
TRACE("mam_int", tout << "bind next candidate:\n" << mk_ll_pp(m_app->get_owner(), m);); \
TRACE("mam_int", tout << "bind next candidate:\n" << mk_ll_pp(m_app->get_expr(), m);); \
m_oreg = m_b->m_oreg
BBIND_COMMON();
@ -2830,7 +2830,7 @@ namespace {
m_pattern_instances.push_back(m_app);
// continue succeeded
update_max_generation(m_app, nullptr); // null indicates a top-level match
TRACE("mam_int", tout << "continue next candidate:\n" << mk_ll_pp(m_app->get_owner(), m););
TRACE("mam_int", tout << "continue next candidate:\n" << mk_ll_pp(m_app->get_expr(), m););
m_num_args = c->m_num_args;
m_oreg = c->m_oreg;
for (unsigned i = 0; i < m_num_args; i++)
@ -3163,7 +3163,7 @@ namespace {
void add_candidate(code_tree * t, enode * app) {
if (t != nullptr) {
TRACE("mam_candidate", tout << "adding candidate:\n" << mk_ll_pp(app->get_owner(), m););
TRACE("mam_candidate", tout << "adding candidate:\n" << mk_ll_pp(app->get_expr(), m););
if (!t->has_candidates())
m_to_match.push_back(t);
t->add_candidate(app);
@ -3221,7 +3221,7 @@ namespace {
if (!r_plbls.may_contain(elem)) {
m_trail_stack.push(mam_value_trail<approx_set>(r_plbls));
r_plbls.insert(elem);
TRACE("trigger_bug", tout << "updating plabels of:\n" << mk_ismt2_pp(c->get_root()->get_owner(), m) << "\n";
TRACE("trigger_bug", tout << "updating plabels of:\n" << mk_ismt2_pp(c->get_root()->get_expr(), m) << "\n";
tout << "new_elem: " << static_cast<unsigned>(elem) << "\n";
tout << "plbls: " << c->get_root()->get_plbls() << "\n";);
TRACE("mam_bug", tout << "updating plabels of: #" << c->get_root()->get_owner_id() << "\n";
@ -3610,7 +3610,7 @@ namespace {
bool is_flat_assoc = lbl->is_flat_associative();
enode * curr_parent_root = curr_parent->get_root();
enode * curr_parent_cg = curr_parent->get_cg();
TRACE("mam_path_tree", tout << "processing parent:\n" << mk_pp(curr_parent->get_owner(), m) << "\n";);
TRACE("mam_path_tree", tout << "processing parent:\n" << mk_pp(curr_parent->get_expr(), m) << "\n";);
TRACE("mam_path_tree", tout << "parent is marked: " << curr_parent->is_marked() << "\n";);
if (filter.may_contain(m_lbl_hasher(lbl)) &&
!curr_parent->is_marked() &&
@ -3639,7 +3639,7 @@ namespace {
is_eq(curr_tree->m_ground_arg, curr_parent->get_arg(curr_tree->m_ground_arg_idx))
)) {
if (curr_tree->m_code) {
TRACE("mam_path_tree", tout << "found candidate " << expr_ref(curr_parent->get_owner(), m) << "\n";);
TRACE("mam_path_tree", tout << "found candidate " << expr_ref(curr_parent->get_expr(), m) << "\n";);
add_candidate(curr_tree->m_code, curr_parent);
}
if (curr_tree->m_first_child) {
@ -3941,7 +3941,7 @@ namespace {
TRACE("missing_instance",
tout << "qa:\n" << mk_ll_pp(qa, m) << "\npat:\n" << mk_ll_pp(pat, m);
for (unsigned i = 0; i < num_bindings; i++)
tout << "#" << bindings[i]->get_expr_id() << "\n" << mk_ll_pp(bindings[i]->get_owner(), m) << "\n";
tout << "#" << bindings[i]->get_expr_id() << "\n" << mk_ll_pp(bindings[i]->get_expr(), m) << "\n";
);
UNREACHABLE();
}
@ -3963,7 +3963,7 @@ namespace {
// This method is invoked when n becomes relevant.
// If lazy == true, then n is not added to the list of candidate enodes for matching. That is, the method just updates the lbls.
void relevant_eh(enode * n, bool lazy) override {
TRACE("trigger_bug", tout << "relevant_eh:\n" << mk_ismt2_pp(n->get_owner(), m) << "\n";
TRACE("trigger_bug", tout << "relevant_eh:\n" << mk_ismt2_pp(n->get_expr(), m) << "\n";
tout << "mam: " << this << "\n";);
TRACE("mam", tout << "relevant_eh: #" << n->get_owner_id() << "\n";);
if (n->has_lbl_hash())
@ -3979,7 +3979,7 @@ namespace {
update_lbls(n, h);
if (is_plbl(lbl))
update_children_plbls(n, h);
TRACE("mam_bug", tout << "adding relevant candidate:\n" << mk_ll_pp(n->get_owner(), m) << "\n";);
TRACE("mam_bug", tout << "adding relevant candidate:\n" << mk_ll_pp(n->get_expr(), m) << "\n";);
if (!lazy)
add_candidate(n);
}

6
src/smt/qi_queue.cpp
View file

@ -140,7 +140,7 @@ namespace smt {
tout << "new instance of " << q->get_qid() << ", weight " << q->get_weight()
<< ", generation: " << generation << ", scope_level: " << m_context.get_scope_level() << ", cost: " << cost << "\n";
for (unsigned i = 0; i < f->get_num_args(); i++) {
tout << "#" << f->get_arg(i)->get_owner_id() << " d:" << f->get_arg(i)->get_owner()->get_depth() << " ";
tout << "#" << f->get_arg(i)->get_expr_id() << " d:" << f->get_arg(i)->get_expr()->get_depth() << " ";
}
tout << "\n";);
TRACE("new_entries_bug", tout << "[qi:insert]\n";);
@ -223,7 +223,7 @@ namespace smt {
auto* ebindings = m_subst(q, num_bindings);
for (unsigned i = 0; i < num_bindings; ++i)
ebindings[i] = bindings[i]->get_owner();
ebindings[i] = bindings[i]->get_expr();
expr_ref instance = m_subst();
TRACE("qi_queue", tout << "new instance:\n" << mk_pp(instance, m) << "\n";);
@ -271,7 +271,7 @@ namespace smt {
if (m.proofs_enabled()) {
expr_ref_vector bindings_e(m);
for (unsigned i = 0; i < num_bindings; ++i) {
bindings_e.push_back(bindings[i]->get_owner());
bindings_e.push_back(bindings[i]->get_expr());
}
app * bare_lemma = m.mk_or(m.mk_not(q), instance);
proof * qi_pr = m.mk_quant_inst(bare_lemma, num_bindings, bindings_e.c_ptr());

4
src/smt/seq_eq_solver.cpp
View file

@ -1110,7 +1110,7 @@ int theory_seq::find_fst_non_empty_idx(expr_ref_vector const& xs) {
if (ctx.e_internalized(e)) {
enode* root = ctx.get_enode(e)->get_root();
rational val;
if (m_autil.is_numeral(root->get_owner(), val) && val.is_zero()) {
if (m_autil.is_numeral(root->get_expr(), val) && val.is_zero()) {
continue;
}
}
@ -1414,7 +1414,7 @@ bool theory_seq::check_length_coherence() {
}
enode* n = ensure_enode(e);
enode* r = n->get_root();
if (r != n && has_length(r->get_owner())) {
if (r != n && has_length(r->get_expr())) {
continue;
}
if (add_length_to_eqc(e)) {

16
src/smt/seq_offset_eq.cpp
View file

@ -59,10 +59,10 @@ void seq_offset_eq::len_offset(expr* e, int val) {
enode* r1 = th.get_root(x);
enode* r2 = th.get_root(y);
for (enode* n1 : *r1) {
if (!seq.str.is_length(n1->get_owner(), e1))
if (!seq.str.is_length(n1->get_expr(), e1))
continue;
for (enode* n2 : *r2) {
if (!seq.str.is_length(n2->get_owner(), e2))
if (!seq.str.is_length(n2->get_expr(), e2))
continue;
if (r1->get_owner_id() > r2->get_owner_id()) {
std::swap(r1, r2);
@ -83,11 +83,11 @@ void seq_offset_eq::len_offset(expr* e, int val) {
void seq_offset_eq::prop_arith_to_len_offset() {
rational val;
for (enode* n : th.get_context().enodes()) {
if (a.is_numeral(n->get_owner(), val) && val.is_int32() && INT_MIN < val.get_int32()) {
TRACE("seq", tout << "offset: " << mk_pp(n->get_owner(), m) << "\n";);
if (a.is_numeral(n->get_expr(), val) && val.is_int32() && INT_MIN < val.get_int32()) {
TRACE("seq", tout << "offset: " << mk_pp(n->get_expr(), m) << "\n";);
enode *next = n->get_next();
while (next != n) {
len_offset(next->get_owner(), val.get_int32());
len_offset(next->get_expr(), val.get_int32());
next = next->get_next();
}
}
@ -100,14 +100,14 @@ bool seq_offset_eq::find(enode* n1, enode* n2, int& offset) const {
if (n1->get_owner_id() > n2->get_owner_id())
std::swap(n1, n2);
return
!a.is_numeral(n1->get_owner()) &&
!a.is_numeral(n2->get_owner()) &&
!a.is_numeral(n1->get_expr()) &&
!a.is_numeral(n2->get_expr()) &&
m_offset_equalities.find(n1, n2, offset);
}
bool seq_offset_eq::contains(enode* r) {
r = r->get_root();
return !a.is_numeral(r->get_owner()) && m_has_offset_equality.contains(r);
return !a.is_numeral(r->get_expr()) && m_has_offset_equality.contains(r);
}
bool seq_offset_eq::propagate() {

2
src/smt/seq_regex.cpp
View file

@ -387,7 +387,7 @@ namespace smt {
rewrite(regex);
lits.push_back(~entry.m_lit);
if (n1 != n2)
lits.push_back(~th.mk_eq(n1->get_owner(), n2->get_owner(), false));
lits.push_back(~th.mk_eq(n1->get_expr(), n2->get_expr(), false));
}
m_s_in_re.push_back(s_in_re(lit, s, regex));
th.get_trail_stack().push(push_back_vector<vector<s_in_re>>(m_s_in_re));

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 {
if (n1->get_owner()->get_decl() != n2->get_owner()->get_decl())
if (n1->get_expr()->get_decl() != n2->get_expr()->get_decl())
return false;
unsigned num_args = n1->get_num_args();
if (num_args != n2->get_num_args())

2
src/smt/smt_arith_value.cpp
View file

@ -119,7 +119,7 @@ namespace smt {
expr_ref _val(m);
enode* next = m_ctx->get_enode(e), *n = next;
do {
e = next->get_owner();
e = next->get_expr();
if (m_tha && m_tha->get_value(next, _val) && a.is_numeral(_val, val)) return true;
if (m_thi && m_thi->get_value(next, _val) && a.is_numeral(_val, val)) return true;
if (m_thr && m_thr->get_value(next, val)) return true;

4
src/smt/smt_cg_table.cpp
View file

@ -207,8 +207,8 @@ namespace smt {
enode_bool_pair cg_table::insert(enode * n) {
// it doesn't make sense to insert a constant.
SASSERT(n->get_num_args() > 0);
SASSERT(!m_manager.is_and(n->get_owner()));
SASSERT(!m_manager.is_or(n->get_owner()));
SASSERT(!m_manager.is_and(n->get_expr()));
SASSERT(!m_manager.is_or(n->get_expr()));
enode * n_prime;
void * t = get_table(n);
switch (static_cast<table_kind>(GET_TAG(t))) {

2
src/smt/smt_checker.cpp
View file

@ -102,7 +102,7 @@ namespace smt {
}
enode * e = get_enode_eq_to(a);
if (e && e->is_bool() && m_context.is_relevant(e)) {
lbool val = m_context.get_assignment(e->get_owner());
lbool val = m_context.get_assignment(e->get_expr());
return val != l_undef && is_true == (val == l_true);
}
return false;

26
src/smt/smt_conflict_resolution.cpp
View file

@ -107,7 +107,7 @@ namespace smt {
SASSERT(m_antecedents);
TRACE("conflict_",
ast_manager& m = get_manager();
tout << mk_pp(lhs->get_owner(), m) << " = " << mk_pp(rhs->get_owner(), m);
tout << mk_pp(lhs->get_expr(), m) << " = " << mk_pp(rhs->get_expr(), m);
switch (js.get_kind()) {
case eq_justification::AXIOM: tout << " axiom\n"; break;
case eq_justification::EQUATION:
@ -129,7 +129,7 @@ namespace smt {
break;
case eq_justification::CONGRUENCE: {
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_owner(), rhs->get_owner());
m_dyn_ack_manager.used_cg_eh(lhs->get_expr(), rhs->get_expr());
unsigned num_args = lhs->get_num_args();
SASSERT(num_args == rhs->get_num_args());
if (js.used_commutativity()) {
@ -177,7 +177,7 @@ namespace smt {
enode * c = find_common_ancestor(n1, n2);
eq_branch2literals(n1, c);
eq_branch2literals(n2, c);
m_dyn_ack_manager.used_eq_eh(n1->get_owner(), n2->get_owner(), c->get_owner());
m_dyn_ack_manager.used_eq_eh(n1->get_expr(), n2->get_expr(), c->get_expr());
}
/**
@ -785,14 +785,14 @@ namespace smt {
SASSERT(m.has_fact(pr));
expr* f1 = nullptr, *f2 = nullptr;
app * fact = to_app(m.get_fact(pr));
app * n1_owner = n1->get_owner();
app * n2_owner = n2->get_owner();
app * n1_owner = n1->get_expr();
app * n2_owner = n2->get_expr();
bool is_eq = m.is_eq(fact, f1, f2);
if (is_eq && is_quantifier(f1)) {
f1 = m_ctx.get_enode(f1)->get_owner();
f1 = m_ctx.get_enode(f1)->get_expr();
}
if (is_eq && is_quantifier(f2)) {
f2 = m_ctx.get_enode(f2)->get_owner();
f2 = m_ctx.get_enode(f2)->get_expr();
}
if (m.is_false(fact) && !m_ctx.is_true(n2) && !m_ctx.is_false(n2)) {
pr = m.mk_hypothesis(m.mk_eq(n1_owner, n2_owner));
@ -853,7 +853,7 @@ namespace smt {
case eq_justification::CONGRUENCE:
num_args = n1->get_num_args();
SASSERT(num_args == n2->get_num_args());
SASSERT(n1->get_owner()->get_decl() == n2->get_owner()->get_decl());
SASSERT(n1->get_expr()->get_decl() == n2->get_expr()->get_decl());
if (js.used_commutativity()) {
bool visited = true;
SASSERT(num_args == 2);
@ -876,8 +876,8 @@ namespace smt {
}
if (!visited)
return nullptr;
app * e1 = n1->get_owner();
app * e2 = n2->get_owner();
app * e1 = n1->get_expr();
app * e2 = n2->get_expr();
app * e2_prime = m.mk_app(e2->get_decl(), e2->get_arg(1), e2->get_arg(0));
proof * pr1 = nullptr;
if (!prs.empty()) {
@ -908,7 +908,7 @@ namespace smt {
}
if (!visited)
return nullptr;
proof * pr = m.mk_congruence(n1->get_owner(), n2->get_owner(), prs.size(), prs.c_ptr());
proof * pr = m.mk_congruence(n1->get_expr(), n2->get_expr(), prs.size(), prs.c_ptr());
m_new_proofs.push_back(pr);
return pr;
}
@ -1218,7 +1218,7 @@ namespace smt {
void conflict_resolution::mk_proof(enode * lhs, enode * rhs) {
SASSERT(!m_eq2proof.contains(lhs, rhs));
if (lhs == rhs) {
proof* pr = m.mk_reflexivity(lhs->get_owner());
proof* pr = m.mk_reflexivity(lhs->get_expr());
m_new_proofs.push_back(pr);
m_eq2proof.insert(lhs, rhs, pr);
return;
@ -1250,7 +1250,7 @@ namespace smt {
for (unsigned i = 0; i < sz; i++) {
tout << mk_ll_pp(prs1[i], m) << "\n";
});
pr = m.mk_transitivity(prs1.size(), prs1.c_ptr(), lhs->get_owner(), rhs->get_owner());
pr = m.mk_transitivity(prs1.size(), prs1.c_ptr(), lhs->get_expr(), rhs->get_expr());
}
m_new_proofs.push_back(pr);
TRACE("proof_gen_bug", tout << "eq2pr_saved: #" << lhs->get_owner_id() << " #" << rhs->get_owner_id() << "\n";);

2
src/smt/smt_consequences.cpp
View file

@ -194,7 +194,7 @@ namespace smt {
break;
}
}
else if (e_internalized(k) && m.are_distinct(v, get_enode(k)->get_root()->get_owner())) {
else if (e_internalized(k) && m.are_distinct(v, get_enode(k)->get_root()->get_expr())) {
to_delete.push_back(k);
}
else if (get_assignment(mk_diseq(k, v)) == l_true) {

44
src/smt/smt_context.cpp
View file

@ -469,7 +469,7 @@ namespace smt {
TRACE("add_eq", tout << "redundant constraint.\n";);
return;
}
IF_VERBOSE(20, verbose_stream() << "merge " << mk_bounded_pp(n1->get_owner(), m) << " " << mk_bounded_pp(n2->get_owner(), m) << "\n");
IF_VERBOSE(20, verbose_stream() << "merge " << mk_bounded_pp(n1->get_expr(), m) << " " << mk_bounded_pp(n2->get_expr(), m) << "\n");
if (r1->is_interpreted() && r2->is_interpreted()) {
TRACE("add_eq", tout << "interpreted roots conflict.\n";);
@ -627,7 +627,7 @@ namespace smt {
lbool val = get_assignment(v);
if (val != l_true) {
if (val == l_false && js.get_kind() == eq_justification::CONGRUENCE)
m_dyn_ack_manager.cg_conflict_eh(n1->get_owner(), n2->get_owner());
m_dyn_ack_manager.cg_conflict_eh(n1->get_expr(), n2->get_expr());
assign(literal(v), mk_justification(eq_propagation_justification(lhs, rhs)));
}
@ -755,7 +755,7 @@ namespace smt {
enode * r2 = n2->get_root();
enode * r1 = n1->get_root();
if (!r1->has_th_vars() && !r2->has_th_vars()) {
TRACE("merge_theory_vars", tout << "Neither have theory vars #" << n1->get_owner()->get_id() << " #" << n2->get_owner()->get_id() << "\n";);
TRACE("merge_theory_vars", tout << "Neither have theory vars #" << n1->get_expr()->get_id() << " #" << n2->get_expr()->get_id() << "\n";);
return;
}
@ -891,7 +891,7 @@ namespace smt {
lbool val2 = get_assignment(v2);
if (val2 != val) {
if (val2 != l_undef && congruent(source, target) && source->get_num_args() > 0)
m_dyn_ack_manager.cg_conflict_eh(source->get_owner(), target->get_owner());
m_dyn_ack_manager.cg_conflict_eh(source->get_expr(), target->get_expr());
assign(literal(v2, sign), mk_justification(mp_iff_justification(source, target)));
}
target = target->get_next();
@ -1041,10 +1041,10 @@ namespace smt {
enode * r1 = n1->get_root();
enode * r2 = n2->get_root();
TRACE("add_diseq", tout << "assigning: #" << n1->get_owner_id() << " != #" << n2->get_owner_id() << "\n";
tout << mk_ll_pp(n1->get_owner(), m) << " != ";
tout << mk_ll_pp(n2->get_owner(), m) << "\n";
tout << mk_ll_pp(r1->get_owner(), m) << " != ";
tout << mk_ll_pp(r2->get_owner(), m) << "\n";
tout << mk_ll_pp(n1->get_expr(), m) << " != ";
tout << mk_ll_pp(n2->get_expr(), m) << "\n";
tout << mk_ll_pp(r1->get_expr(), m) << " != ";
tout << mk_ll_pp(r2->get_expr(), m) << "\n";
);
DEBUG_CODE(
@ -1102,13 +1102,13 @@ namespace smt {
SASSERT(n1->get_sort() == n2->get_sort());
context * _this = const_cast<context*>(this);
if (!m_is_diseq_tmp) {
app * eq = m.mk_eq(n1->get_owner(), n2->get_owner());
app * eq = m.mk_eq(n1->get_expr(), n2->get_expr());
m.inc_ref(eq);
_this->m_is_diseq_tmp = enode::mk_dummy(m, m_app2enode, eq);
}
else if (m_is_diseq_tmp->get_owner()->get_arg(0)->get_sort() != n1->get_sort()) {
m.dec_ref(m_is_diseq_tmp->get_owner());
app * eq = m.mk_eq(n1->get_owner(), n2->get_owner());
else if (m_is_diseq_tmp->get_expr()->get_arg(0)->get_sort() != n1->get_sort()) {
m.dec_ref(m_is_diseq_tmp->get_expr());
app * eq = m.mk_eq(n1->get_expr(), n2->get_expr());
m.inc_ref(eq);
m_is_diseq_tmp->m_func_decl_id = UINT_MAX;
m_is_diseq_tmp->m_owner = eq;
@ -1136,7 +1136,7 @@ namespace smt {
if (n1->get_num_parents() > n2->get_num_parents())
std::swap(n1, n2);
for (enode * parent : enode::parents(n1)) {
if (parent->is_eq() && is_relevant(parent->get_owner()) && get_assignment(enode2bool_var(parent)) == l_false &&
if (parent->is_eq() && is_relevant(parent->get_expr()) && get_assignment(enode2bool_var(parent)) == l_false &&
((parent->get_arg(0)->get_root() == n1->get_root() && parent->get_arg(1)->get_root() == n2->get_root()) ||
(parent->get_arg(1)->get_root() == n1->get_root() && parent->get_arg(0)->get_root() == n2->get_root()))) {
TRACE("is_diseq_bug", tout << "parent: #" << parent->get_owner_id() << ", parent->root: #" <<
@ -1253,14 +1253,14 @@ namespace smt {
enode * r = m_cg_table.find(tmp);
#ifdef Z3DEBUG
if (r != nullptr) {
SASSERT(r->get_owner()->get_decl() == f);
SASSERT(r->get_expr()->get_decl() == f);
SASSERT(r->get_num_args() == num_args);
if (r->is_commutative()) {
// TODO
}
else {
for (unsigned i = 0; i < num_args; i++) {
expr * arg = r->get_owner()->get_arg(i);
expr * arg = r->get_expr()->get_arg(i);
SASSERT(e_internalized(arg));
enode * _arg = get_enode(arg);
CTRACE("eq_to_bug", args[i]->get_root() != _arg->get_root(),
@ -1434,7 +1434,7 @@ namespace smt {
return;
}
theory_id th_id = th->get_id();
TRACE("push_new_th_diseqs", tout << "#" << r->get_owner_id() << " " << mk_bounded_pp(r->get_owner(), m) << " v" << v << " th: " << th_id << "\n";);
TRACE("push_new_th_diseqs", tout << "#" << r->get_owner_id() << " " << mk_bounded_pp(r->get_expr(), m) << " v" << v << " th: " << th_id << "\n";);
for (enode * parent : r->get_parents()) {
CTRACE("parent_bug", parent == 0, tout << "#" << r->get_owner_id() << ", num_parents: " << r->get_num_parents() << "\n"; display(tout););
if (parent->is_eq()) {
@ -1518,7 +1518,7 @@ namespace smt {
If the enode is not boolean, then return l_undef.
*/
lbool context::get_assignment(enode * n) const {
expr * owner = n->get_owner();
expr * owner = n->get_expr();
if (!m.is_bool(owner))
return l_undef;
if (n == m_false_enode)
@ -2953,7 +2953,7 @@ namespace smt {
m_qmanager = nullptr;
if (m_is_diseq_tmp) {
m_is_diseq_tmp->del_eh(m, false);
m.dec_ref(m_is_diseq_tmp->get_owner());
m.dec_ref(m_is_diseq_tmp->get_expr());
enode::del_dummy(m_is_diseq_tmp);
m_is_diseq_tmp = nullptr;
}
@ -4354,8 +4354,8 @@ namespace smt {
bool context::assume_eq(enode * lhs, enode * rhs) {
if (lhs->get_root() == rhs->get_root())
return false; // it is not necessary to assume the eq.
expr * _lhs = lhs->get_owner();
expr * _rhs = rhs->get_owner();
expr * _lhs = lhs->get_expr();
expr * _rhs = rhs->get_expr();
expr * eq = mk_eq_atom(_lhs, _rhs);
TRACE("assume_eq", tout << "creating interface eq:\n" << mk_pp(eq, m) << "\n";);
if (m.is_false(eq)) {
@ -4412,7 +4412,7 @@ namespace smt {
bool context::is_shared(enode * n) const {
n = n->get_root();
unsigned num_th_vars = n->get_num_th_vars();
if (m.is_ite(n->get_owner())) {
if (m.is_ite(n->get_expr())) {
return true;
}
switch (num_th_vars) {
@ -4431,7 +4431,7 @@ namespace smt {
theory_id th_id = l->get_id();
for (enode * parent : enode::parents(n)) {
app* p = parent->get_owner();
app* p = parent->get_expr();
family_id fid = p->get_family_id();
if (fid != th_id && fid != m.get_basic_family_id()) {
TRACE("is_shared", tout << enode_pp(n, *this)

8
src/smt/smt_context.h
View file

@ -297,7 +297,7 @@ namespace smt {
}
bool_var get_bool_var(enode const * n) const {
return get_bool_var(n->get_owner());
return get_bool_var(n->get_expr());
}
bool_var get_bool_var_of_id(unsigned id) const {
@ -1084,7 +1084,7 @@ namespace smt {
void push_eq(enode * lhs, enode * rhs, eq_justification const & js) {
if (lhs->get_root() != rhs->get_root()) {
SASSERT(lhs->get_owner()->get_sort() == rhs->get_owner()->get_sort());
SASSERT(lhs->get_expr()->get_sort() == rhs->get_expr()->get_sort());
m_eq_propagation_queue.push_back(new_eq(lhs, rhs, js));
}
}
@ -1269,7 +1269,7 @@ namespace smt {
}
bool is_relevant(enode * n) const {
return is_relevant(n->get_owner());
return is_relevant(n->get_expr());
}
bool is_relevant(bool_var v) const {
@ -1287,7 +1287,7 @@ namespace smt {
void mark_as_relevant(expr * n) { m_relevancy_propagator->mark_as_relevant(n); m_relevancy_propagator->propagate(); }
void mark_as_relevant(enode * n) { mark_as_relevant(n->get_owner()); }
void mark_as_relevant(enode * n) { mark_as_relevant(n->get_expr()); }
void mark_as_relevant(bool_var v) { mark_as_relevant(bool_var2expr(v)); }

24
src/smt/smt_context_inv.cpp
View file

@ -160,7 +160,7 @@ namespace smt {
if (n->is_true_eq() && n2->is_true_eq())
continue;
CTRACE("missing_propagation", congruent(n, n2),
tout << mk_pp(n->get_owner(), m) << "\n" << mk_pp(n2->get_owner(), m) << "\n";
tout << mk_pp(n->get_expr(), m) << "\n" << mk_pp(n2->get_expr(), m) << "\n";
display(tout););
SASSERT(!congruent(n, n2));
}
@ -171,12 +171,12 @@ namespace smt {
bool context::check_missing_bool_enode_propagation() const {
for (enode* n : m_enodes) {
if (m.is_bool(n->get_owner()) && get_assignment(n) == l_undef) {
if (m.is_bool(n->get_expr()) && get_assignment(n) == l_undef) {
enode * first = n;
do {
CTRACE("missing_propagation", get_assignment(n) != l_undef,
tout << mk_pp(first->get_owner(), m) << "\nassignment: " << get_assignment(first) << "\n"
<< mk_pp(n->get_owner(), m) << "\nassignment: " << get_assignment(n) << "\n";);
tout << mk_pp(first->get_expr(), m) << "\nassignment: " << get_assignment(first) << "\n"
<< mk_pp(n->get_expr(), m) << "\nassignment: " << get_assignment(n) << "\n";);
SASSERT(get_assignment(n) == l_undef);
n = n->get_next();
}
@ -232,11 +232,11 @@ namespace smt {
*/
bool context::check_eqc_bool_assignment() const {
for (enode* e : m_enodes) {
if (m.is_bool(e->get_owner())) {
if (m.is_bool(e->get_expr())) {
enode * r = e->get_root();
CTRACE("eqc_bool", get_assignment(e) != get_assignment(r),
tout << "#" << e->get_expr_id() << "\n" << mk_pp(e->get_owner(), m) << "\n";
tout << "#" << r->get_expr_id() << "\n" << mk_pp(r->get_owner(), m) << "\n";
tout << "#" << e->get_expr_id() << "\n" << mk_pp(e->get_expr(), m) << "\n";
tout << "#" << r->get_expr_id() << "\n" << mk_pp(r->get_expr(), m) << "\n";
tout << "assignments: " << get_assignment(e) << " " << get_assignment(r) << "\n";
display(tout););
SASSERT(get_assignment(e) == get_assignment(r));
@ -270,8 +270,8 @@ namespace smt {
for (bool_var v = 0; v < num; v++) {
if (has_enode(v)) {
enode * n = bool_var2enode(v);
if (n->is_eq() && is_relevant(n) && get_assignment(v) == l_false && !m.is_iff(n->get_owner())) {
TRACE("check_th_diseq_propagation", tout << "checking: #" << n->get_expr_id() << " " << mk_bounded_pp(n->get_owner(), m) << "\n";);
if (n->is_eq() && is_relevant(n) && get_assignment(v) == l_false && !m.is_iff(n->get_expr())) {
TRACE("check_th_diseq_propagation", tout << "checking: #" << n->get_expr_id() << " " << mk_bounded_pp(n->get_expr(), m) << "\n";);
enode * lhs = n->get_arg(0)->get_root();
enode * rhs = n->get_arg(1)->get_root();
if (rhs->is_interpreted() && lhs->is_interpreted())
@ -279,7 +279,7 @@ namespace smt {
if (lhs == rhs)
continue;
TRACE("check_th_diseq_propagation", tout << "num. theory_vars: " << lhs->get_num_th_vars() << " "
<< mk_pp(lhs->get_owner()->get_sort(), m) << "\n";);
<< mk_pp(lhs->get_expr()->get_sort(), m) << "\n";);
theory_var_list * l = lhs->get_th_var_list();
while (l) {
theory_id th_id = l->get_id();
@ -306,9 +306,9 @@ namespace smt {
tout
<< "checking theory: " << m.get_family_name(th_id) << "\n"
<< "root: #" << n->get_root()->get_expr_id() << " node: #" << n->get_expr_id() << "\n"
<< mk_pp(n->get_owner(), m) << "\n"
<< mk_pp(n->get_expr(), m) << "\n"
<< "lhs: #" << lhs->get_expr_id() << ", rhs: #" << rhs->get_expr_id() << "\n"
<< mk_bounded_pp(lhs->get_owner(), m) << " " << mk_bounded_pp(rhs->get_owner(), m) << "\n";);
<< mk_bounded_pp(lhs->get_expr(), m) << " " << mk_bounded_pp(rhs->get_expr(), m) << "\n";);
VERIFY(found);
}
l = l->get_next();

14
src/smt/smt_context_pp.cpp
View file

@ -146,7 +146,7 @@ namespace smt {
void context::display_enode_defs(std::ostream & out) const {
for (enode * x : m_enodes) {
expr * n = x->get_owner();
expr * n = x->get_expr();
ast_def_ll_pp(out, m, n, get_pp_visited(), true, false);
}
}
@ -246,8 +246,8 @@ namespace smt {
void context::display_eqc(std::ostream & out) const {
bool first = true;
for (enode * x : m_enodes) {
expr * n = x->get_owner();
expr * r = x->get_root()->get_owner();
expr * n = x->get_expr();
expr * r = x->get_root()->get_expr();
if (n != r) {
if (first) {
out << "equivalence classes:\n";
@ -457,7 +457,7 @@ namespace smt {
}
for (unsigned i = 0; i < num_eq_antecedents; i++) {
enode_pair const & p = eq_antecedents[i];
n = m.mk_eq(p.first->get_owner(), p.second->get_owner());
n = m.mk_eq(p.first->get_expr(), p.second->get_expr());
fmls.push_back(n);
}
if (consequent != false_literal) {
@ -509,14 +509,14 @@ namespace smt {
out << std::left << n->get_owner_id() << " #";
out.width(5);
out << n->get_root()->get_owner_id() << " := " << std::right;
unsigned num = n->get_owner()->get_num_args();
unsigned num = n->get_expr()->get_num_args();
if (num > 0)
out << "(";
out << n->get_decl()->get_name();
if (!n->get_decl()->private_parameters())
display_parameters(out, n->get_decl()->get_num_parameters(), n->get_decl()->get_parameters());
for (unsigned i = 0; i < num; i++) {
expr * arg = n->get_owner()->get_arg(i);
expr * arg = n->get_expr()->get_arg(i);
if (e_internalized(arg)) {
enode * n = get_enode(arg)->get_root();
out << " #" << n->get_owner_id();
@ -658,7 +658,7 @@ namespace smt {
std::ostream& operator<<(std::ostream& out, enode_pp const& p) {
ast_manager& m = p.ctx.get_manager();
enode* n = p.n;
return out << "[#" << n->get_owner_id() << " " << mk_bounded_pp(n->get_owner(), m) << "]";
return out << "[#" << n->get_owner_id() << " " << mk_bounded_pp(n->get_expr(), m) << "]";
}
std::ostream& operator<<(std::ostream& out, enode_eq_pp const& p) {

2
src/smt/smt_enode.cpp
View file

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

3
src/smt/smt_enode.h
View file

@ -21,6 +21,7 @@ Revision History:
#include "util/id_var_list.h"
#include "util/approx_set.h"
#include "ast/ast.h"
#include "ast/ast_pp.h"
#include "smt/smt_types.h"
#include "smt/smt_eq_justification.h"
@ -165,7 +166,6 @@ namespace smt {
void del_eh(ast_manager & m, bool update_children_parent = true);
app * get_owner() const { return m_owner; }
app * get_expr() const { return m_owner; }
unsigned get_owner_id() const { return m_owner->get_id(); }
@ -453,6 +453,7 @@ namespace smt {
void reset();
};
inline mk_pp pp(enode* n, ast_manager& m) { return mk_pp(n->get_expr(), m); }
};

22
src/smt/smt_induction.cpp
View file

@ -113,14 +113,14 @@ bool induction_lemmas::viable_induction_sort(sort* s) {
}
bool induction_lemmas::viable_induction_parent(enode* p, enode* n) {
app* o = p->get_owner();
app* o = p->get_expr();
return
m_rec.is_defined(o) ||
m_dt.is_constructor(o);
}
bool induction_lemmas::viable_induction_children(enode* n) {
app* e = n->get_owner();
app* e = n->get_expr();
if (m.is_value(e))
return false;
if (e->get_decl()->is_skolem())
@ -136,7 +136,7 @@ bool induction_lemmas::viable_induction_children(enode* n) {
bool induction_lemmas::viable_induction_term(enode* p, enode* n) {
return
viable_induction_sort(n->get_owner()->get_sort()) &&
viable_induction_sort(n->get_expr()->get_sort()) &&
viable_induction_parent(p, n) &&
viable_induction_children(n);
}
@ -201,7 +201,7 @@ induction_lemmas::induction_positions_t induction_lemmas::induction_positions2(e
}
void induction_lemmas::initialize_levels(enode* n) {
expr_ref tmp(n->get_owner(), m);
expr_ref tmp(n->get_expr(), m);
m_depth2terms.reset();
m_depth2terms.resize(get_depth(tmp) + 1);
m_ts++;
@ -221,7 +221,7 @@ induction_lemmas::induction_combinations_t induction_lemmas::induction_combinati
if (pos.size() > 6) {
induction_positions_t r;
for (auto const& p : pos) {
if (is_uninterp_const(p.first->get_owner()))
if (is_uninterp_const(p.first->get_expr()))
r.push_back(p);
}
result.push_back(r);
@ -239,7 +239,7 @@ induction_lemmas::induction_combinations_t induction_lemmas::induction_combinati
for (auto const& pos : result) {
std::cout << "position\n";
for (auto const& p : pos) {
std::cout << mk_pp(p.first->get_owner(), m) << ":" << p.second << "\n";
std::cout << mk_pp(p.first->get_expr(), m) << ":" << p.second << "\n";
}
}
return result;
@ -252,7 +252,7 @@ bool induction_lemmas::positions_dont_overlap(induction_positions_t const& posit
auto mark = [&](expr* n) { m_marks[n->get_id()] = m_ts; };
auto is_marked = [&](expr* n) { return m_marks[n->get_id()] == m_ts; };
for (auto p : positions)
mark(p.first->get_owner());
mark(p.first->get_expr());
// no term used for induction contains a subterm also used for induction.
for (auto const& terms : m_depth2terms) {
for (app* t : terms) {
@ -456,7 +456,7 @@ void induction_lemmas::apply_induction(literal lit, induction_positions_t const
unsigned i = 0;
for (auto const& p : positions) {
expr* t = p.first->get_owner()->get_arg(p.second);
expr* t = p.first->get_expr()->get_arg(p.second);
if (term2skolem.contains(t))
continue;
if (i == sks.size()) {
@ -500,7 +500,7 @@ void induction_lemmas::apply_induction(literal lit, induction_positions_t const
expr* arg = to_app(t)->get_arg(i);
found = false;
for (auto const& p : positions) {
if (p.first->get_owner() == t && p.second == i) {
if (p.first->get_expr() == t && p.second == i) {
args.push_back(term2skolem[arg]);
found = true;
break;
@ -558,10 +558,10 @@ induction::induction(context& ctx, ast_manager& m):
// TBD: use smt_arith_value to also include state from arithmetic solver
void induction::init_values() {
for (enode* n : ctx.enodes())
if (m.is_value(n->get_owner()))
if (m.is_value(n->get_expr()))
for (enode* r : *n)
if (r != n) {
vs.set_value(r->get_owner(), n->get_owner());
vs.set_value(r->get_expr(), n->get_expr());
}
}

2
src/smt/smt_induction.h
View file

@ -69,7 +69,7 @@ namespace smt {
unsigned operator()(induction_term_and_position_t const& t) const {
unsigned a = get_node_hash(t.m_term);
for (auto const& p : t.m_positions) {
a = mk_mix(a, p.second, get_node_hash(p.first->get_owner()));
a = mk_mix(a, p.second, get_node_hash(p.first->get_expr()));
}
return a;
}

12
src/smt/smt_justification.cpp
View file

@ -139,8 +139,8 @@ namespace smt {
if (!visited)
return nullptr;
expr * lhs = m_node1->get_root()->get_owner();
expr * rhs = m_node2->get_root()->get_owner();
expr * lhs = m_node1->get_root()->get_expr();
expr * rhs = m_node2->get_root()->get_expr();
proof * pr1 = m.mk_transitivity(prs.size(), prs.c_ptr(), lhs, rhs);
proof * pr2 = m.mk_rewrite(m.mk_eq(lhs, rhs), m.mk_false());
return m.mk_modus_ponens(pr1, pr2);
@ -152,8 +152,8 @@ namespace smt {
proof * eq_root_propagation_justification::mk_proof(conflict_resolution & cr) {
ast_manager & m = cr.get_manager();
expr * var = m_node->get_owner();
expr * val = m_node->get_root()->get_owner();
expr * var = m_node->get_expr();
expr * val = m_node->get_root()->get_expr();
SASSERT(m.is_true(val) || m.is_false(val));
proof * pr1 = cr.get_proof(m_node, m_node->get_root());
if (pr1) {
@ -191,7 +191,7 @@ namespace smt {
proof * mp_iff_justification::mk_proof(conflict_resolution & cr) {
ast_manager& m = cr.get_manager();
if (m_node1 == m_node2)
return m.mk_reflexivity(m_node1->get_owner());
return m.mk_reflexivity(m_node1->get_expr());
proof * pr1 = cr.get_proof(m_node1, m_node2);
context & ctx = cr.get_context();
bool_var v = ctx.enode2bool_var(m_node1);
@ -357,7 +357,7 @@ namespace smt {
return nullptr;
ast_manager & m = cr.get_manager();
context & ctx = cr.get_context();
expr * fact = ctx.mk_eq_atom(m_lhs->get_owner(), m_rhs->get_owner());
expr * fact = ctx.mk_eq_atom(m_lhs->get_expr(), m_rhs->get_expr());
return m.mk_th_lemma(m_th_id, fact, prs.size(), prs.c_ptr(), m_params.size(), m_params.c_ptr());
}

2
src/smt/smt_model_checker.cpp
View file

@ -112,7 +112,7 @@ namespace smt {
enode * n = kv.m_key;
expr * val = kv.m_value;
n = n->get_eq_enode_with_min_gen();
m_value2expr.insert(val, n->get_owner());
m_value2expr.insert(val, n->get_expr());
}
}
}

24
src/smt/smt_model_finder.cpp
View file

@ -1177,7 +1177,7 @@ namespace smt {
// So, using n->get_arg(m_arg_i)->get_root(), we may miss
// a necessary instantiation.
enode* e_arg = n->get_arg(m_arg_i);
expr* arg = e_arg->get_owner();
expr* arg = e_arg->get_expr();
A_f_i->insert(arg, e_arg->get_generation());
}
}
@ -1195,7 +1195,7 @@ namespace smt {
for (enode* n : ctx->enodes_of(m_f)) {
if (ctx->is_relevant(n)) {
enode* e_arg = n->get_arg(m_arg_i);
expr* arg = e_arg->get_owner();
expr* arg = e_arg->get_expr();
s->insert(arg, e_arg->get_generation());
}
}
@ -1247,7 +1247,7 @@ namespace smt {
bv_util bv(m);
bv_rewriter bv_rw(m);
enode* e_arg = n->get_arg(m_arg_i);
expr* arg = e_arg->get_owner();
expr* arg = e_arg->get_expr();
expr_ref arg_minus_k(m);
if (bv.is_bv(arg))
bv_rw.mk_sub(arg, m_offset, arg_minus_k);
@ -1348,7 +1348,7 @@ namespace smt {
enode_vector::iterator end2 = curr->end_parents();
for (; it2 != end2; ++it2) {
enode* p = *it2;
if (ctx->is_relevant(p) && p->get_owner()->get_decl() == auf_arr->get_decl()) {
if (ctx->is_relevant(p) && p->get_expr()->get_decl() == auf_arr->get_decl()) {
arrays.push_back(p);
}
}
@ -1398,11 +1398,11 @@ namespace smt {
TRACE("select_var",
tout << "enodes matching: "; display(tout); tout << "\n";
for (enode* n : arrays) {
tout << "#" << n->get_owner()->get_id() << "\n" << mk_pp(n->get_owner(), m) << "\n";
tout << "#" << n->get_expr_id() << "\n" << mk_pp(n->get_expr(), m) << "\n";
});
node* n1 = s.get_uvar(q, m_var_j);
for (enode* n : arrays) {
app* ground_array = n->get_owner();
app* ground_array = n->get_expr();
func_decl* f = get_array_func_decl(ground_array, s);
if (f) {
SASSERT(m_arg_i >= 1);
@ -1416,7 +1416,7 @@ namespace smt {
ptr_buffer<enode> arrays;
get_auf_arrays(get_array(), ctx, arrays);
for (enode* curr : arrays) {
app* ground_array = curr->get_owner();
app* ground_array = curr->get_expr();
func_decl* f = get_array_func_decl(ground_array, s);
if (f) {
node* A_f_i = s.get_A_f_i(f, m_arg_i - 1);
@ -1424,10 +1424,10 @@ namespace smt {
enode_vector::iterator end2 = curr->end_parents();
for (; it2 != end2; ++it2) {
enode* p = *it2;
if (ctx->is_relevant(p) && p->get_owner()->get_decl() == m_select->get_decl()) {
SASSERT(m_arg_i < p->get_owner()->get_num_args());
if (ctx->is_relevant(p) && p->get_expr()->get_decl() == m_select->get_decl()) {
SASSERT(m_arg_i < p->get_expr()->get_num_args());
enode* e_arg = p->get_arg(m_arg_i);
A_f_i->insert(e_arg->get_owner(), e_arg->get_generation());
A_f_i->insert(e_arg->get_expr(), e_arg->get_generation());
}
}
}
@ -1558,8 +1558,8 @@ namespace smt {
// See Section 4.1 in the paper "Complete Quantifier Instantiation"
node* S_q_i = slv.get_uvar(q, m_var_i);
for (enode* n : ctx->enodes()) {
if (ctx->is_relevant(n) && n->get_owner()->get_sort() == s) {
S_q_i->insert(n->get_owner(), n->get_generation());
if (ctx->is_relevant(n) && n->get_expr()->get_sort() == s) {
S_q_i->insert(n->get_expr(), n->get_generation());
}
}
}

24
src/smt/smt_model_generator.cpp
View file

@ -98,7 +98,7 @@ namespace smt {
model_value_proc * proc = nullptr;
if (m.is_bool(s)) {
CTRACE("model", m_context->get_assignment(r) == l_undef,
tout << mk_pp(r->get_owner(), m) << "\n";);
tout << mk_pp(r->get_expr(), m) << "\n";);
SASSERT(m_context->get_assignment(r) != l_undef);
if (m_context->get_assignment(r) == l_true)
proc = alloc(expr_wrapper_proc, m.mk_true());
@ -134,12 +134,12 @@ namespace smt {
model_value_proc* model_generator::mk_model_value(enode* r) {
SASSERT(r == r->get_root());
expr * n = r->get_owner();
expr * n = r->get_expr();
if (!m.is_model_value(n)) {
sort * s = r->get_sort();
n = m_model->get_fresh_value(s);
CTRACE("model", n == 0,
tout << mk_pp(r->get_owner(), m) << "\nsort:\n" << mk_pp(s, m) << "\n";
tout << mk_pp(r->get_expr(), m) << "\nsort:\n" << mk_pp(s, m) << "\n";
tout << "is_finite: " << m_model->is_finite(s) << "\n";);
}
return alloc(expr_wrapper_proc, to_app(n));
@ -209,7 +209,7 @@ namespace smt {
}
TRACE("mg_top_sort",
tout << "src: " << src << " ";
tout << mk_pp(n->get_owner(), m) << "\n";
tout << mk_pp(n->get_expr(), m) << "\n";
for (model_value_dependency const& dep : dependencies) {
tout << "#" << n->get_owner_id() << " -> " << dep << " already visited: " << visited << "\n";
}
@ -306,7 +306,7 @@ namespace smt {
else {
enode * n = curr.get_enode();
SASSERT(n->get_root() == n);
tout << mk_pp(n->get_owner(), m) << "\n";
tout << mk_pp(n->get_expr(), m) << "\n";
sort * s = n->get_sort();
tout << curr << " " << mk_pp(s, m);
tout << " is_fresh: " << root2proc[n]->is_fresh() << "\n";
@ -338,14 +338,14 @@ namespace smt {
for (model_value_dependency const& d : dependencies) {
if (d.is_fresh_value()) {
CTRACE("mg_top_sort", !d.get_value()->get_value(),
tout << "#" << n->get_owner_id() << " " << mk_pp(n->get_owner(), m) << " -> " << d << "\n";);
tout << "#" << n->get_owner_id() << " " << mk_pp(n->get_expr(), m) << " -> " << d << "\n";);
SASSERT(d.get_value()->get_value());
dependency_values.push_back(d.get_value()->get_value());
}
else {
enode * child = d.get_enode();
TRACE("mg_top_sort", tout << "#" << n->get_owner_id() << " (" << mk_pp(n->get_owner(), m) << "): "
<< mk_pp(child->get_owner(), m) << " " << mk_pp(child->get_root()->get_owner(), m) << "\n";);
TRACE("mg_top_sort", tout << "#" << n->get_owner_id() << " (" << mk_pp(n->get_expr(), m) << "): "
<< mk_pp(child->get_expr(), m) << " " << mk_pp(child->get_root()->get_expr(), m) << "\n";);
child = child->get_root();
dependency_values.push_back(m_root2value[child]);
}
@ -358,8 +358,8 @@ namespace smt {
}
// send model
for (enode * n : m_context->enodes()) {
if (is_uninterp_const(n->get_owner()) && m_context->is_relevant(n)) {
func_decl * d = n->get_owner()->get_decl();
if (is_uninterp_const(n->get_expr()) && m_context->is_relevant(n)) {
func_decl * d = n->get_expr()->get_decl();
TRACE("mg_top_sort", tout << d->get_name() << " " << (m_hidden_ufs.contains(d)?"hidden":"visible") << "\n";);
if (m_hidden_ufs.contains(d)) continue;
expr * val = get_value(n);
@ -427,7 +427,7 @@ namespace smt {
SASSERT(m_model->get_func_interp(f) == fi);
// The entry must be new because n->get_cg() == n
TRACE("model",
tout << "insert new entry for:\n" << mk_ismt2_pp(n->get_owner(), m) << "\nargs: ";
tout << "insert new entry for:\n" << mk_ismt2_pp(n->get_expr(), m) << "\nargs: ";
for (unsigned i = 0; i < num_args; i++) {
tout << "#" << n->get_arg(i)->get_owner_id() << " ";
}
@ -468,7 +468,7 @@ namespace smt {
void model_generator::register_existing_model_values() {
for (enode * r : m_context->enodes()) {
if (r == r->get_root() && m_context->is_relevant(r)) {
expr * n = r->get_owner();
expr * n = r->get_expr();
if (m.is_model_value(n)) {
register_value(n);
}

2
src/smt/smt_quantifier.cpp
View file

@ -316,7 +316,7 @@ namespace smt {
CTRACE("bindings", f != nullptr,
tout << expr_ref(q, m()) << "\n";
for (unsigned i = 0; i < num_bindings; ++i) {
tout << expr_ref(bindings[i]->get_owner(), m()) << " [r " << bindings[i]->get_root()->get_owner_id() << "] ";
tout << expr_ref(bindings[i]->get_expr(), m()) << " [r " << bindings[i]->get_root()->get_owner_id() << "] ";
}
tout << "\n";
);

8
src/smt/smt_quick_checker.cpp
View file

@ -358,10 +358,10 @@ namespace smt {
if (idx >= m_num_bindings)
return n;
// VAR 0 is stored in the last position of m_bindings
return m_bindings[m_num_bindings - idx - 1]->get_root()->get_owner();
return m_bindings[m_num_bindings - idx - 1]->get_root()->get_expr();
}
if (m_context.e_internalized(n))
return m_context.get_enode(n)->get_root()->get_owner();
return m_context.get_enode(n)->get_root()->get_expr();
if (!is_app(n) || to_app(n)->get_num_args() == 0)
return n;
expr * r;
@ -382,8 +382,8 @@ namespace smt {
if (has_arg_enodes) {
enode * e = m_context.get_enode_eq_to(to_app(n)->get_decl(), num_args, new_arg_enodes.c_ptr());
if (e) {
m_canonize_cache.insert(n, e->get_root()->get_owner());
return e->get_root()->get_owner();
m_canonize_cache.insert(n, e->get_root()->get_expr());
return e->get_root()->get_expr();
}
}
// substitute by values in the model

4
src/smt/smt_relevancy.cpp
View file

@ -333,7 +333,7 @@ namespace smt {
if (e != nullptr) {
enode * curr = e;
do {
set_relevant(curr->get_owner());
set_relevant(curr->get_expr());
curr = curr->get_next();
}
while (curr != e);
@ -625,7 +625,7 @@ namespace smt {
if (n0 != 0) {
enode * n = n0->get_next();
while (n0 != n) {
SASSERT(is_relevant(n->get_owner()));
SASSERT(is_relevant(n->get_expr()));
n = n->get_next();
}
}

6
src/smt/smt_theory.h
View file

@ -404,7 +404,7 @@ namespace smt {
}
app * get_expr(theory_var v) const {
return get_enode(v)->get_owner();
return get_enode(v)->get_expr();
}
/**
@ -447,9 +447,9 @@ namespace smt {
std::ostream& display_flat_app(std::ostream & out, app * n) const;
std::ostream& display_var_def(std::ostream & out, theory_var v) const { return display_app(out, get_enode(v)->get_owner()); }
std::ostream& display_var_def(std::ostream & out, theory_var v) const { return display_app(out, get_enode(v)->get_expr()); }
std::ostream& display_var_flat_def(std::ostream & out, theory_var v) const { return display_flat_app(out, get_enode(v)->get_owner()); }
std::ostream& display_var_flat_def(std::ostream & out, theory_var v) const { return display_flat_app(out, get_enode(v)->get_expr()); }
protected:
void log_axiom_instantiation(app * r, unsigned axiom_id = UINT_MAX, unsigned num_bindings = 0,

4
src/smt/theory_arith.h
View file

@ -531,7 +531,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; }
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_owner(); }
expr * var2expr(theory_var v) const { return get_enode(v)->get_expr(); }
bool reflection_enabled() const;
bool reflect(app * n) const;
unsigned lazy_pivoting_lvl() const { return m_params.m_arith_lazy_pivoting_lvl; }
@ -973,7 +973,7 @@ namespace smt {
\brief A monomial is 'pure' if does not have a numeric coefficient.
*/
bool is_pure_monomial(expr * m) const { return m_util.is_mul(m) && (to_app(m)->get_num_args() > 2 || !m_util.is_numeral(to_app(m)->get_arg(0))); }
bool is_pure_monomial(theory_var v) const { return is_pure_monomial(get_enode(v)->get_owner()); }
bool is_pure_monomial(theory_var v) const { return is_pure_monomial(get_enode(v)->get_expr()); }
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 get_non_linear_cluster(svector<theory_var> & vars);

26
src/smt/theory_arith_aux.h
View file

@ -430,8 +430,8 @@ namespace smt {
template<typename Ext>
void theory_arith<Ext>::eq_bound::display(theory_arith<Ext> const& th, std::ostream& out) const {
ast_manager& m = th.get_manager();
out << "#" << m_lhs->get_owner_id() << " " << mk_pp(m_lhs->get_owner(), m) << " = "
<< "#" << m_rhs->get_owner_id() << " " << mk_pp(m_rhs->get_owner(), m);
out << "#" << m_lhs->get_owner_id() << " " << mk_pp(m_lhs->get_expr(), m) << " = "
<< "#" << m_rhs->get_owner_id() << " " << mk_pp(m_rhs->get_expr(), m);
}
// -----------------------------------
@ -761,8 +761,8 @@ namespace smt {
enode* a = e.first;
enode* b = e.second;
out << " ";
out << "#" << a->get_owner_id() << " " << mk_pp(a->get_owner(), m) << " = "
<< "#" << b->get_owner_id() << " " << mk_pp(b->get_owner(), m) << "\n";
out << "#" << a->get_owner_id() << " " << mk_pp(a->get_expr(), m) << " = "
<< "#" << b->get_owner_id() << " " << mk_pp(b->get_expr(), m) << "\n";
}
for (literal l : m_lits) {
out << l << ":"; th.ctx.display_detailed_literal(out, l) << "\n";
@ -1086,7 +1086,7 @@ namespace smt {
expr_ref theory_arith<Ext>::mk_gt(theory_var v) {
ast_manager& m = get_manager();
inf_numeral const& val = get_value(v);
expr* obj = get_enode(v)->get_owner();
expr* obj = get_enode(v)->get_expr();
expr_ref e(m);
rational r = val.get_rational();
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) {
ast_manager& m = get_manager();
std::ostringstream strm;
strm << val << " <= " << mk_pp(get_enode(v)->get_owner(), get_manager());
strm << val << " <= " << mk_pp(get_enode(v)->get_expr(), get_manager());
app* b = m.mk_const(symbol(strm.str()), m.mk_bool_sort());
expr_ref result(b, m);
TRACE("opt", tout << result << "\n";);
@ -1205,8 +1205,8 @@ namespace smt {
}
for (unsigned i = 0; i < num_eqs; ++i) {
enode_pair const& p = eqs[i];
x = p.first->get_owner();
y = p.second->get_owner();
x = p.first->get_expr();
y = p.second->get_expr();
tmp = m.mk_eq(x,y);
}
@ -1228,8 +1228,8 @@ namespace smt {
}
for (unsigned i = 0; i < num_eqs; ++i) {
enode_pair const& p = eqs[i];
x = p.first->get_owner();
y = p.second->get_owner();
x = p.first->get_expr();
y = p.second->get_expr();
tmp = m.mk_eq(x,y);
parameter const& pa = params[1 + num_lits + i];
SASSERT(pa.is_rational());
@ -1798,7 +1798,7 @@ namespace smt {
*/
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) {
expr* e = get_enode(v)->get_owner();
expr* e = get_enode(v)->get_expr();
(void)e;
SASSERT(!maintain_integrality || valid_assignment());
SASSERT(satisfy_bounds());
@ -2179,7 +2179,7 @@ namespace smt {
TRACE("shared", tout << ctx.get_scope_level() << " " << v << " " << r->get_num_parents() << "\n";);
for (; it != end; ++it) {
enode * parent = *it;
app * o = parent->get_owner();
app * o = parent->get_expr();
if (o->get_family_id() == get_id()) {
switch (o->get_decl_kind()) {
case OP_DIV:
@ -2209,7 +2209,7 @@ namespace smt {
int num = get_num_vars();
for (theory_var v = 0; v < num; v++) {
enode * n = get_enode(v);
TRACE("func_interp_bug", tout << mk_pp(n->get_owner(), get_manager()) << " -> " << m_value[v] << " root #" << n->get_root()->get_owner_id() << " " << is_relevant_and_shared(n) << "\n";);
TRACE("func_interp_bug", tout << mk_pp(n->get_expr(), get_manager()) << " -> " << m_value[v] << " root #" << n->get_root()->get_owner_id() << " " << is_relevant_and_shared(n) << "\n";);
if (!is_relevant_and_shared(n)) {
continue;
}

28
src/smt/theory_arith_core.h
View file

@ -103,8 +103,8 @@ namespace smt {
theory_var r = theory::mk_var(n);
SASSERT(r == static_cast<int>(m_columns.size()));
SASSERT(check_vector_sizes());
bool is_int = is_int_expr(n->get_owner());
TRACE("mk_arith_var", tout << mk_pp(n->get_owner(), m) << " is_int: " << is_int << "\n";);
bool is_int = is_int_expr(n->get_expr());
TRACE("mk_arith_var", tout << mk_pp(n->get_expr(), m) << " is_int: " << is_int << "\n";);
m_columns .push_back(column());
m_data .push_back(var_data(is_int));
if (random_initial_value()) {
@ -127,12 +127,12 @@ namespace smt {
m_in_update_trail_stack.assure_domain(r);
m_left_basis.assure_domain(r);
m_in_to_check.assure_domain(r);
if (is_pure_monomial(n->get_owner()))
if (is_pure_monomial(n->get_expr()))
m_nl_monomials.push_back(r);
SASSERT(check_vector_sizes());
SASSERT(m_var_occs[r].empty());
TRACE("mk_arith_var",
tout << "#" << n->get_owner_id() << " :=\n" << mk_ll_pp(n->get_owner(), m) << "\n";
tout << "#" << n->get_owner_id() << " :=\n" << mk_ll_pp(n->get_expr(), m) << "\n";
tout << "is_attached_to_var: " << is_attached_to_var(n) << ", var: " << n->get_th_var(get_id()) << "\n";);
ctx.attach_th_var(n, this, r);
SASSERT(m_var_occs.back().empty());
@ -1349,26 +1349,26 @@ namespace smt {
template<typename Ext>
void theory_arith<Ext>::new_eq_eh(theory_var v1, theory_var v2) {
TRACE("arith_new_eq_eh", tout << "#" << get_enode(v1)->get_owner_id() << " = #" << get_enode(v2)->get_owner_id() << "\n";);
TRACE("arith_new_eq_eh_detail", tout << mk_pp(get_enode(v1)->get_owner(), m) << "\n" <<
mk_pp(get_enode(v2)->get_owner(), m) << "\n";);
TRACE("arith_new_eq_eh_detail", tout << mk_pp(get_enode(v1)->get_expr(), m) << "\n" <<
mk_pp(get_enode(v2)->get_expr(), m) << "\n";);
enode * n1 = get_enode(v1);
if (!m_util.is_int(n1->get_owner()) &&
!m_util.is_real(n1->get_owner())) {
if (!m_util.is_int(n1->get_expr()) &&
!m_util.is_real(n1->get_expr())) {
return;
}
if (m_params.m_arith_eq_bounds) {
enode * n2 = get_enode(v2);
SASSERT(n1->get_root() == n2->get_root());
if (m_util.is_numeral(n1->get_owner())) {
if (m_util.is_numeral(n1->get_expr())) {
std::swap(v1, v2);
std::swap(n1, n2);
}
rational k;
bound * b1 = nullptr;
bound * b2 = nullptr;
if (m_util.is_numeral(n2->get_owner(), k)) {
if (m_util.is_numeral(n2->get_expr(), k)) {
inf_numeral val(k);
b1 = alloc(eq_bound, v1, val, B_LOWER, n1, n2);
b2 = alloc(eq_bound, v1, val, B_UPPER, n1, n2);
@ -1376,9 +1376,9 @@ namespace smt {
else {
if (n1->get_owner_id() > n2->get_owner_id())
std::swap(n1, n2);
sort * st = n1->get_owner()->get_sort();
sort * st = n1->get_expr()->get_sort();
app * minus_one = m_util.mk_numeral(rational::minus_one(), st);
app * s = m_util.mk_add(n1->get_owner(), m_util.mk_mul(minus_one, n2->get_owner()));
app * s = m_util.mk_add(n1->get_expr(), m_util.mk_mul(minus_one, n2->get_expr()));
ctx.internalize(s, false);
enode * e_s = ctx.get_enode(s);
ctx.mark_as_relevant(e_s);
@ -1404,8 +1404,8 @@ namespace smt {
template<typename Ext>
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_owner(), m) << "\n" <<
mk_bounded_pp(get_enode(v2)->get_owner(), m) << "\n";);
TRACE("arith_new_diseq_eh", tout << mk_bounded_pp(get_enode(v1)->get_expr(), m) << "\n" <<
mk_bounded_pp(get_enode(v2)->get_expr(), m) << "\n";);
m_stats.m_assert_diseq++;
m_arith_eq_adapter.new_diseq_eh(v1, v2);
}

6
src/smt/theory_arith_eq.h
View file

@ -43,7 +43,7 @@ namespace smt {
return;
numeral const & val = lower_bound(v).get_rational();
value_sort_pair key(val, is_int_src(v));
TRACE("arith_eq", tout << mk_pp(get_enode(v)->get_owner(), get_manager()) << " = " << val << "\n";);
TRACE("arith_eq", tout << mk_pp(get_enode(v)->get_expr(), get_manager()) << " = " << val << "\n";);
theory_var v2;
if (m_fixed_var_table.find(key, v2)) {
if (v2 < static_cast<int>(get_num_vars()) && is_fixed(v2) && lower_bound(v2).get_rational() == val) {
@ -349,10 +349,10 @@ namespace smt {
tout << "\n";
}
for (auto const& p : eqs) {
tout << mk_pp(p.first->get_owner(), m) << " = " << mk_pp(p.second->get_owner(), m) << "\n";
tout << mk_pp(p.first->get_expr(), m) << " = " << mk_pp(p.second->get_expr(), m) << "\n";
}
tout << " ==> ";
tout << mk_pp(_x->get_owner(), m) << " = " << mk_pp(_y->get_owner(), m) << "\n";
tout << mk_pp(_x->get_expr(), m) << " = " << mk_pp(_y->get_expr(), m) << "\n";
);
ctx.assign_eq(_x, _y, eq_justification(js));
}

10
src/smt/theory_arith_int.h
View file

@ -213,7 +213,7 @@ namespace smt {
tout << "k = " << k << ", _k = "<< _k << std::endl;
);
expr_ref bound(m);
expr* e = get_enode(v)->get_owner();
expr* e = get_enode(v)->get_expr();
bound = m_util.mk_ge(e, m_util.mk_numeral(_k, m_util.is_int(e)));
context & ctx = get_context();
{
@ -411,7 +411,7 @@ namespace smt {
for (; it != end; ++it) {
if (!it->is_dead() && it->m_var != b && is_free(it->m_var)) {
theory_var v = it->m_var;
expr* e = get_enode(v)->get_owner();
expr* e = get_enode(v)->get_expr();
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());
context & ctx = get_context();
@ -465,7 +465,7 @@ namespace smt {
for (unsigned i = 0; i < num_args; i++) {
rational _k = args[i].m_coeff.to_rational();
expr * x = get_enode(args[i].m_var)->get_owner();
expr * x = get_enode(args[i].m_var)->get_expr();
if (m_util.is_int(x) && !all_int)
x = m_util.mk_to_real(x);
if (_k.is_one())
@ -635,9 +635,9 @@ namespace smt {
}
rational _k = k.to_rational();
if (is_lower)
bound = m_util.mk_ge(get_enode(v)->get_owner(), m_util.mk_numeral(_k, is_int(v)));
bound = m_util.mk_ge(get_enode(v)->get_expr(), m_util.mk_numeral(_k, is_int(v)));
else
bound = m_util.mk_le(get_enode(v)->get_owner(), m_util.mk_numeral(_k, is_int(v)));
bound = m_util.mk_le(get_enode(v)->get_expr(), m_util.mk_numeral(_k, is_int(v)));
}
else {
if (num_ints > 0) {

2
src/smt/theory_arith_nl.h
View file

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

6
src/smt/theory_arith_pp.h
View file

@ -422,8 +422,8 @@ namespace smt {
if (!lits().empty()) out << "\n";
ast_manager& m = th.get_manager();
for (auto const& e : m_eqs) {
out << mk_pp(e.first->get_owner(), m) << " ";
out << mk_pp(e.second->get_owner(), m) << "\n";
out << mk_pp(e.first->get_expr(), m) << " ";
out << mk_pp(e.second->get_expr(), m) << "\n";
}
return out;
}
@ -508,7 +508,7 @@ namespace smt {
pp.set_benchmark_name("lemma");
int n = get_num_vars();
for (theory_var v = 0; v < n; v++) {
expr * n = get_enode(v)->get_owner();
expr * n = get_enode(v)->get_expr();
if (is_fixed(v)) {
inf_numeral k_inf = lower_bound(v);
rational k = k_inf.get_rational().to_rational();

18
src/smt/theory_array.cpp
View file

@ -43,7 +43,7 @@ namespace smt {
// v1 is the new root
TRACE("array",
tout << "merging v" << v1 << " v" << v2 << "\n"; display_var(tout, v1);
tout << mk_pp(get_enode(v1)->get_owner(), m) << " <- " << mk_pp(get_enode(v2)->get_owner(), m) << "\n";);
tout << mk_pp(get_enode(v1)->get_expr(), m) << " <- " << mk_pp(get_enode(v2)->get_expr(), m) << "\n";);
SASSERT(v1 == find(v1));
var_data * d1 = m_var_data[v1];
var_data * d2 = m_var_data[v2];
@ -68,11 +68,11 @@ namespace smt {
SASSERT(r == static_cast<int>(m_var_data.size()));
m_var_data.push_back(alloc(var_data));
var_data * d = m_var_data[r];
TRACE("array", tout << mk_bounded_pp(n->get_owner(), m) << "\nis_array: " << is_array_sort(n) << ", is_select: " << is_select(n) <<
TRACE("array", tout << mk_bounded_pp(n->get_expr(), m) << "\nis_array: " << is_array_sort(n) << ", is_select: " << is_select(n) <<
", is_store: " << is_store(n) << "\n";);
d->m_is_array = is_array_sort(n);
if (d->m_is_array)
register_sort(n->get_owner()->get_sort());
register_sort(n->get_expr()->get_sort());
d->m_is_select = is_select(n);
if (is_store(n))
d->m_stores.push_back(n);
@ -89,7 +89,7 @@ namespace smt {
v = find(v);
var_data * d = m_var_data[v];
d->m_parent_selects.push_back(s);
TRACE("array", tout << v << " " << mk_pp(s->get_owner(), m) << " " << mk_pp(get_enode(v)->get_owner(), m) << "\n";);
TRACE("array", tout << v << " " << mk_pp(s->get_expr(), m) << " " << mk_pp(get_enode(v)->get_expr(), m) << "\n";);
m_trail_stack.push(push_back_trail<enode *, false>(d->m_parent_selects));
for (enode* n : d->m_stores) {
instantiate_axiom2a(s, n);
@ -196,7 +196,7 @@ namespace smt {
}
void theory_array::instantiate_axiom1(enode * store) {
TRACE("array", tout << "axiom 1:\n" << mk_bounded_pp(store->get_owner(), m) << "\n";);
TRACE("array", tout << "axiom 1:\n" << mk_bounded_pp(store->get_expr(), m) << "\n";);
SASSERT(is_store(store));
m_stats.m_num_axiom1++;
assert_store_axiom1(store);
@ -296,8 +296,8 @@ namespace smt {
void theory_array::new_eq_eh(theory_var v1, theory_var v2) {
m_find.merge(v1, v2);
enode* n1 = get_enode(v1), *n2 = get_enode(v2);
if (n1->get_owner()->get_decl()->is_lambda() ||
n2->get_owner()->get_decl()->is_lambda()) {
if (n1->get_expr()->get_decl()->is_lambda() ||
n2->get_expr()->get_decl()->is_lambda()) {
assert_congruent(n1, n2);
}
}
@ -307,8 +307,8 @@ namespace smt {
v2 = find(v2);
var_data * d1 = m_var_data[v1];
TRACE("ext", tout << "extensionality: " << d1->m_is_array << "\n"
<< mk_bounded_pp(get_enode(v1)->get_owner(), m, 5) << "\n"
<< mk_bounded_pp(get_enode(v2)->get_owner(), m, 5) << "\n";);
<< mk_bounded_pp(get_enode(v1)->get_expr(), m, 5) << "\n"
<< mk_bounded_pp(get_enode(v2)->get_expr(), m, 5) << "\n";);
if (d1->m_is_array) {
SASSERT(m_var_data[v2]->m_is_array);

6
src/smt/theory_array_bapa.cpp
View file

@ -128,7 +128,7 @@ namespace smt {
}
bool is_true(expr* e) { return is_true(ctx().get_literal(e)); }
bool is_true(enode* e) { return is_true(e->get_owner()); }
bool is_true(enode* e) { return is_true(e->get_expr()); }
bool is_true(literal l) { return ctx().is_relevant(l) && ctx().get_assignment(l) == l_true; }
bool is_leaf(sz_info& i) const { return i.m_is_leaf; }
bool is_leaf(sz_info* i) const { return is_leaf(*i); }
@ -167,7 +167,7 @@ namespace smt {
for (enode* parent : enode::parents(set)) {
if (is_select(parent) && parent->get_arg(0)->get_root() == set) {
if (is_true(parent)) {
v.m_selects.insert(parent->get_arg(1)->get_root(), parent->get_owner());
v.m_selects.insert(parent->get_arg(1)->get_root(), parent->get_expr());
}
}
}
@ -424,7 +424,7 @@ namespace smt {
if (info.m_selects.size() > 1) {
ptr_vector<expr> args;
for (auto const& kv : info.m_selects) {
args.push_back(kv.m_key->get_owner());
args.push_back(kv.m_key->get_expr());
}
if (info.m_selects.size() == 2) {
lits.push_back(mk_eq(args[0], args[1]));

52
src/smt/theory_array_base.cpp
View file

@ -94,7 +94,7 @@ namespace smt {
}
void theory_array_base::assert_store_axiom1_core(enode * e) {
app * n = e->get_owner();
app * n = e->get_expr();
SASSERT(is_store(n));
ptr_buffer<expr> sel_args;
unsigned num_args = n->get_num_args();
@ -134,7 +134,7 @@ namespace smt {
*/
void theory_array_base::assert_store_axiom2_core(enode * store, enode * select) {
TRACE("array", tout << "generating axiom2: #" << store->get_owner_id() << " #" << select->get_owner_id() << "\n";
tout << mk_bounded_pp(store->get_owner(), m) << "\n" << mk_bounded_pp(select->get_owner(), m) << "\n";);
tout << mk_bounded_pp(store->get_expr(), m) << "\n" << mk_bounded_pp(select->get_expr(), m) << "\n";);
SASSERT(is_store(store));
SASSERT(is_select(select));
SASSERT(store->get_num_args() == 1 + select->get_num_args());
@ -144,12 +144,12 @@ namespace smt {
enode * const * is = select->get_args() + 1;
enode * const * js = store->get_args() + 1;
unsigned num_args = select->get_num_args() - 1;
sel1_args.push_back(store->get_owner());
sel2_args.push_back(a->get_owner());
sel1_args.push_back(store->get_expr());
sel2_args.push_back(a->get_expr());
for (unsigned i = 0; i < num_args; i++) {
sel1_args.push_back(is[i]->get_owner());
sel2_args.push_back(is[i]->get_owner());
sel1_args.push_back(is[i]->get_expr());
sel2_args.push_back(is[i]->get_expr());
}
expr_ref sel1(m), sel2(m);
@ -179,14 +179,14 @@ namespace smt {
conseq_expr = ctx.bool_var2expr(conseq.var());
}
literal ante = mk_eq(idx1->get_owner(), idx2->get_owner(), true);
literal ante = mk_eq(idx1->get_expr(), idx2->get_expr(), true);
ctx.mark_as_relevant(ante);
// ctx.force_phase(ante);
ctx.add_rel_watch(~ante, conseq_expr);
// ctx.mark_as_relevant(conseq_expr);
TRACE("array", tout << "asserting axiom2: " << ante << "\n";);
TRACE("array_map_bug", tout << "axiom2:\n";
tout << mk_ismt2_pp(idx1->get_owner(), m) << "\n=\n" << mk_ismt2_pp(idx2->get_owner(), m);
tout << mk_ismt2_pp(idx1->get_expr(), m) << "\n=\n" << mk_ismt2_pp(idx2->get_expr(), m);
tout << "\nimplies\n" << mk_ismt2_pp(conseq_expr, m) << "\n";);
if (m.has_trace_stream()) {
app_ref body(m);
@ -264,7 +264,7 @@ namespace smt {
for (enode* parent : r1->get_const_parents()) {
if (parent->is_cgr() &&
ctx.is_relevant(parent) &&
is_select(parent->get_owner()) &&
is_select(parent->get_expr()) &&
parent->get_arg(0)->get_root() == r1) {
m_array_value.insert(parent);
}
@ -274,7 +274,7 @@ namespace smt {
enode * other;
if (parent->is_cgr() &&
ctx.is_relevant(parent) &&
is_select(parent->get_owner()) &&
is_select(parent->get_expr()) &&
parent->get_arg(0)->get_root() == r2 &&
m_array_value.find(parent, other)) {
@ -313,8 +313,8 @@ namespace smt {
void theory_array_base::assert_extensionality_core(enode * n1, enode * n2) {
app * e1 = n1->get_owner();
app * e2 = n2->get_owner();
app * e1 = n1->get_expr();
app * e2 = n2->get_expr();
func_decl_ref_vector * funcs = nullptr;
sort * s = e1->get_sort();
@ -351,8 +351,8 @@ namespace smt {
\brief assert n1 = n2 => forall vars . (n1 vars) = (n2 vars)
*/
void theory_array_base::assert_congruent_core(enode * n1, enode * n2) {
app * e1 = n1->get_owner();
app * e2 = n2->get_owner();
app * e1 = n1->get_expr();
app * e2 = n2->get_expr();
sort* s = e1->get_sort();
unsigned dimension = get_array_arity(s);
literal n1_eq_n2 = mk_eq(e1, e2, true);
@ -564,15 +564,15 @@ namespace smt {
TRACE("array_bug", tout << "mk_interface_eqs: processing: v" << *it1 << "\n";);
theory_var v1 = *it1;
enode * n1 = get_enode(v1);
sort * s1 = n1->get_owner()->get_sort();
sort * s1 = n1->get_expr()->get_sort();
sbuffer<theory_var>::iterator it2 = it1;
++it2;
for (; it2 != end1; ++it2) {
theory_var v2 = *it2;
enode * n2 = get_enode(v2);
sort * s2 = n2->get_owner()->get_sort();
sort * s2 = n2->get_expr()->get_sort();
if (s1 == s2 && !ctx.is_diseq(n1, n2)) {
app * eq = mk_eq_atom(n1->get_owner(), n2->get_owner());
app * eq = mk_eq_atom(n1->get_expr(), n2->get_expr());
if (!ctx.b_internalized(eq) || !ctx.is_relevant(eq)) {
result++;
ctx.internalize(eq, true);
@ -624,7 +624,7 @@ namespace smt {
void theory_array_base::set_default(theory_var v, enode* n) {
TRACE("array", tout << "set default: " << v << " " << mk_pp(n->get_owner(), m) << "\n";);
TRACE("array", tout << "set default: " << v << " " << pp(n, m) << "\n";);
v = mg_find(v);
if (m_defaults[v] == 0) {
m_defaults[v] = n;
@ -672,8 +672,8 @@ namespace smt {
m_defaults[u] = m_defaults[v];
}
CTRACE("array", m_defaults[v],
tout << mk_pp(m_defaults[v]->get_root()->get_owner(), m) << "\n";
tout << mk_pp(m_defaults[u]->get_root()->get_owner(), m) << "\n";
tout << pp(m_defaults[v]->get_root(), m) << "\n";
tout << pp(m_defaults[u]->get_root(), m) << "\n";
);
// NB. it may be the case that m_defaults[u] != m_defaults[v]
@ -748,7 +748,7 @@ namespace smt {
mg_merge(v, get_representative(w));
TRACE("array", tout << "merge: " << mk_pp(n->get_owner(), m) << " " << v << " " << w << "\n";);
TRACE("array", tout << "merge: " << pp(n, m) << " " << v << " " << w << "\n";);
}
else if (is_const(n)) {
set_default(v, n->get_arg(0));
@ -983,7 +983,7 @@ namespace smt {
SASSERT(ctx.is_relevant(n));
theory_var v = n->get_th_var(get_id());
SASSERT(v != null_theory_var);
sort * s = n->get_owner()->get_sort();
sort * s = n->get_expr()->get_sort();
enode * else_val_n = get_default(v);
array_value_proc * result = nullptr;
@ -1008,7 +1008,7 @@ namespace smt {
// The implementation should not assume a fresh value is created for
// the else_val if the range is finite
TRACE("array", tout << mk_pp(n->get_owner(), m) << " " << mk_pp(range, m) << " " << range->is_infinite() << "\n";);
TRACE("array", tout << pp(n, m) << " " << mk_pp(range, m) << " " << range->is_infinite() << "\n";);
if (range->is_infinite())
else_val = TAG(void*, mg.mk_extra_fresh_value(range), 1);
else
@ -1038,14 +1038,14 @@ namespace smt {
}
}
TRACE("array",
tout << mk_pp(n->get_root()->get_owner(), m) << "\n";
tout << pp(n->get_root(), m) << "\n";
if (sel_set) {
for (enode* s : *sel_set) {
tout << "#" << s->get_root()->get_owner()->get_id() << " " << mk_pp(s->get_owner(), m) << "\n";
tout << "#" << s->get_root()->get_expr_id() << " " << pp(s, m) << "\n";
}
}
if (else_val_n) {
tout << "else: " << mk_pp(else_val_n->get_owner(), m) << "\n";
tout << "else: " << pp(else_val_n, m) << "\n";
});
return result;
}

22
src/smt/theory_array_base.h
View file

@ -35,8 +35,8 @@ namespace smt {
void add_weak_var(theory_var v);
virtual void set_prop_upward(theory_var v) {}
void found_unsupported_op(expr * n);
void found_unsupported_op(enode* n) { found_unsupported_op(n->get_owner()); }
void found_unsupported_op(theory_var v) { found_unsupported_op(get_enode(v)->get_owner()); }
void found_unsupported_op(enode* n) { found_unsupported_op(n->get_expr()); }
void found_unsupported_op(theory_var v) { found_unsupported_op(get_enode(v)->get_expr()); }
bool is_store(app const* n) const { return 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); }
@ -50,15 +50,15 @@ namespace smt {
bool is_set_has_size(app const* n) const { return n->is_app_of(get_id(), OP_SET_HAS_SIZE); }
bool is_set_card(app const* n) const { return n->is_app_of(get_id(), OP_SET_CARD); }
bool is_store(enode const * n) const { return is_store(n->get_owner()); }
bool is_map(enode const* n) const { return is_map(n->get_owner()); }
bool is_select(enode const* n) const { return is_select(n->get_owner()); }
bool is_const(enode const* n) const { return is_const(n->get_owner()); }
bool is_as_array(enode const * n) const { return is_as_array(n->get_owner()); }
bool is_default(enode const* n) const { return is_default(n->get_owner()); }
bool is_array_sort(enode const* n) const { return is_array_sort(n->get_owner()); }
bool is_set_has_size(enode const* n) const { return is_set_has_size(n->get_owner()); }
bool is_set_carde(enode const* n) const { return is_set_card(n->get_owner()); }
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_select(enode const* n) const { return is_select(n->get_expr()); }
bool is_const(enode const* n) const { return is_const(n->get_expr()); }
bool is_as_array(enode const * n) const { return is_as_array(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_set_has_size(enode const* n) const { return is_set_has_size(n->get_expr()); }
bool is_set_carde(enode const* n) const { return is_set_card(n->get_expr()); }
bool is_select_arg(enode* r);
app * mk_select(unsigned num_args, expr * const * args);

52
src/smt/theory_array_full.cpp
View file

@ -134,7 +134,7 @@ namespace smt {
// call set_prop_upward on array arguments.
//
void theory_array_full::set_prop_upward(enode * n) {
TRACE("array", tout << mk_pp(n->get_owner(), m) << "\n";);
TRACE("array", tout << pp(n, m) << "\n";);
if (is_store(n)) {
set_prop_upward(n->get_arg(0)->get_th_var(get_id()));
}
@ -344,8 +344,8 @@ namespace smt {
add_as_array(v1, n);
}
TRACE("array",
tout << mk_pp(get_enode(v1)->get_owner(), m) << "\n";
tout << mk_pp(get_enode(v2)->get_owner(), m) << "\n";
tout << pp(get_enode(v1), m) << "\n";
tout << pp(get_enode(v2), m) << "\n";
tout << "merge in\n"; display_var(tout, v2);
tout << "after merge\n"; display_var(tout, v1););
}
@ -354,7 +354,7 @@ namespace smt {
SASSERT(v != null_theory_var);
v = find(v);
var_data* d = m_var_data[v];
TRACE("array", tout << "v" << v << " " << mk_pp(get_enode(v)->get_owner(), m) << " "
TRACE("array", tout << "v" << v << " " << pp(get_enode(v), m) << " "
<< d->m_prop_upward << " " << m_params.m_array_delay_exp_axiom << "\n";);
for (enode * store : d->m_stores) {
SASSERT(is_store(store));
@ -368,7 +368,7 @@ namespace smt {
void theory_array_full::add_parent_select(theory_var v, enode * s) {
TRACE("array",
tout << v << " select parent: " << mk_pp(s->get_owner(), m) << "\n";
tout << v << " select parent: " << pp(s, m) << "\n";
display_var(tout, v);
);
theory_array::add_parent_select(v,s);
@ -446,8 +446,8 @@ namespace smt {
// 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) {
app* map = mp->get_owner();
app* select = sl->get_owner();
app* map = mp->get_expr();
app* select = sl->get_expr();
SASSERT(is_map(map));
SASSERT(is_select(select));
SASSERT(map->get_num_args() > 0);
@ -456,7 +456,7 @@ namespace smt {
TRACE("array_map_bug", tout << "invoked instantiate_select_map_axiom\n";
tout << sl->get_owner_id() << " " << mp->get_owner_id() << "\n";
tout << mk_ismt2_pp(sl->get_owner(), m) << "\n" << mk_ismt2_pp(mp->get_owner(), m) << "\n";);
tout << mk_ismt2_pp(sl->get_expr(), m) << "\n" << mk_ismt2_pp(mp->get_expr(), m) << "\n";);
if (!ctx.add_fingerprint(mp, mp->get_owner_id(), sl->get_num_args() - 1, sl->get_args() + 1)) {
return false;
@ -466,8 +466,8 @@ namespace smt {
m_stats.m_num_map_axiom++;
TRACE("array",
tout << mk_bounded_pp(mp->get_owner(), m) << "\n";
tout << mk_bounded_pp(sl->get_owner(), m) << "\n";);
tout << mk_bounded_pp(mp->get_expr(), m) << "\n";
tout << mk_bounded_pp(sl->get_expr(), m) << "\n";);
unsigned num_args = select->get_num_args();
unsigned num_arrays = map->get_num_args();
ptr_buffer<expr> args1, args2;
@ -513,7 +513,7 @@ namespace smt {
bool theory_array_full::instantiate_default_map_axiom(enode* mp) {
SASSERT(is_map(mp));
app* map = mp->get_owner();
app* map = mp->get_expr();
if (!ctx.add_fingerprint(this, m_default_map_fingerprint, 1, &mp)) {
return false;
}
@ -543,9 +543,9 @@ namespace smt {
}
m_stats.m_num_default_const_axiom++;
SASSERT(is_const(cnst));
TRACE("array", tout << mk_bounded_pp(cnst->get_owner(), m) << "\n";);
expr* val = cnst->get_arg(0)->get_owner();
expr* def = mk_default(cnst->get_owner());
TRACE("array", tout << mk_bounded_pp(cnst->get_expr(), m) << "\n";);
expr* val = cnst->get_arg(0)->get_expr();
expr* def = mk_default(cnst->get_expr());
ctx.internalize(def, false);
return try_assign_eq(val, def);
}
@ -626,15 +626,15 @@ namespace smt {
m_stats.m_num_select_const_axiom++;
ptr_buffer<expr> sel_args;
sel_args.push_back(cnst->get_owner());
sel_args.push_back(cnst->get_expr());
for (unsigned short i = 1; i < num_args; ++i) {
sel_args.push_back(select->get_owner()->get_arg(i));
sel_args.push_back(select->get_expr()->get_arg(i));
}
expr * sel = mk_select(sel_args.size(), sel_args.c_ptr());
expr * val = cnst->get_owner()->get_arg(0);
expr * val = cnst->get_expr()->get_arg(0);
TRACE("array", tout << "new select-const axiom...\n";
tout << "const: " << mk_bounded_pp(cnst->get_owner(), m) << "\n";
tout << "select: " << mk_bounded_pp(select->get_owner(), m) << "\n";
tout << "const: " << mk_bounded_pp(cnst->get_expr(), m) << "\n";
tout << "select: " << mk_bounded_pp(select->get_expr(), m) << "\n";
tout << " sel/const: " << mk_bounded_pp(sel, m) << "\n";
tout << "value: " << mk_bounded_pp(val, m) << "\n";
tout << "#" << sel->get_id() << " = #" << val->get_id() << "\n";
@ -650,7 +650,7 @@ namespace smt {
// 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) {
SASSERT(is_as_array(arr->get_owner()));
SASSERT(is_as_array(arr->get_expr()));
SASSERT(is_select(select));
SASSERT(arr->get_num_args() == 0);
unsigned num_args = select->get_num_args();
@ -660,16 +660,16 @@ namespace smt {
m_stats.m_num_select_as_array_axiom++;
ptr_buffer<expr> sel_args;
sel_args.push_back(arr->get_owner());
sel_args.push_back(arr->get_expr());
for (unsigned short i = 1; i < num_args; ++i) {
sel_args.push_back(select->get_owner()->get_arg(i));
sel_args.push_back(select->get_expr()->get_arg(i));
}
expr * sel = mk_select(sel_args.size(), sel_args.c_ptr());
func_decl * f = array_util(m).get_as_array_func_decl(arr->get_owner());
func_decl * f = array_util(m).get_as_array_func_decl(arr->get_expr());
expr_ref val(m.mk_app(f, sel_args.size()-1, sel_args.c_ptr()+1), m);
TRACE("array", tout << "new select-as-array axiom...\n";
tout << "as-array: " << mk_bounded_pp(arr->get_owner(), m) << "\n";
tout << "select: " << mk_bounded_pp(select->get_owner(), m) << "\n";
tout << "as-array: " << mk_bounded_pp(arr->get_expr(), m) << "\n";
tout << "select: " << mk_bounded_pp(select->get_expr(), m) << "\n";
tout << " sel/as-array: " << mk_bounded_pp(sel, m) << "\n";
tout << "value: " << mk_bounded_pp(val.get(), m) << "\n";
tout << "#" << sel->get_id() << " = #" << val->get_id() << "\n";
@ -684,7 +684,7 @@ namespace smt {
bool theory_array_full::instantiate_default_store_axiom(enode* store) {
SASSERT(is_store(store));
SASSERT(store->get_num_args() >= 3);
app* store_app = store->get_owner();
app* store_app = store->get_expr();
if (!ctx.add_fingerprint(this, m_default_store_fingerprint, store->get_num_args(), store->get_args())) {
return false;
}

22
src/smt/theory_bv.cpp
View file

@ -45,7 +45,7 @@ namespace smt {
void theory_bv::mk_bits(theory_var v) {
enode * n = get_enode(v);
app * owner = n->get_owner();
app * owner = n->get_expr();
unsigned bv_size = get_bv_size(n);
bool is_relevant = ctx.is_relevant(n);
literal_vector & bits = m_bits[v];
@ -180,7 +180,7 @@ namespace smt {
return n->get_arg(idx);
}
else {
app * arg = to_app(n->get_owner()->get_arg(idx));
app * arg = to_app(n->get_expr()->get_arg(idx));
SASSERT(ctx.e_internalized(arg));
return ctx.get_enode(arg);
}
@ -418,7 +418,7 @@ namespace smt {
}
if (!visited)
return nullptr;
expr * fact = ctx.mk_eq_atom(m_th.get_enode(m_var1)->get_owner(), m_th.get_enode(m_var2)->get_owner());
expr * fact = ctx.mk_eq_atom(m_th.get_enode(m_var1)->get_expr(), m_th.get_enode(m_var2)->get_expr());
ast_manager & m = ctx.get_manager();
return m.mk_th_lemma(get_from_theory(), fact, prs.size(), prs.c_ptr());
}
@ -444,8 +444,8 @@ namespace smt {
return;
}
++m_stats.m_num_eq_dynamic;
app* o1 = get_enode(v1)->get_owner();
app* o2 = get_enode(v2)->get_owner();
app* o1 = get_enode(v1)->get_expr();
app* o2 = get_enode(v2)->get_expr();
literal oeq = mk_eq(o1, o2, true);
unsigned sz = get_bv_size(v1);
TRACE("bv",
@ -479,7 +479,7 @@ namespace smt {
VERIFY(get_fixed_value(v, val));
enode* n = get_enode(v);
if (ctx.watches_fixed(n)) {
expr_ref num(m_util.mk_numeral(val, n->get_owner()->get_sort()), m);
expr_ref num(m_util.mk_numeral(val, n->get_expr()->get_sort()), m);
literal_vector& lits = m_tmp_literals;
lits.reset();
for (literal b : m_bits[v]) {
@ -1101,16 +1101,16 @@ namespace smt {
}
void theory_bv::apply_sort_cnstr(enode * n, sort * s) {
if (!is_attached_to_var(n) && !approximate_term(n->get_owner())) {
if (!is_attached_to_var(n) && !approximate_term(n->get_expr())) {
mk_bits(mk_var(n));
if (ctx.is_relevant(n)) {
relevant_eh(n->get_owner());
relevant_eh(n->get_expr());
}
}
}
void theory_bv::new_eq_eh(theory_var v1, theory_var v2) {
TRACE("bv_eq", tout << "new_eq: " << mk_pp(get_enode(v1)->get_owner(), m) << " = " << mk_pp(get_enode(v2)->get_owner(), m) << "\n";);
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", tout << "new_eq_eh v" << v1 << " = v" << v2 << " @ " << ctx.get_scope_level() <<
" relevant1: " << ctx.is_relevant(get_enode(v1)) <<
" relevant2: " << ctx.is_relevant(get_enode(v2)) << "\n";);
@ -1176,7 +1176,7 @@ namespace smt {
literal_vector & lits = m_tmp_literals;
lits.reset();
literal eq = mk_eq(get_enode(v1)->get_owner(), get_enode(v2)->get_owner(), true);
literal eq = mk_eq(get_enode(v1)->get_expr(), get_enode(v2)->get_expr(), true);
lits.push_back(eq);
it1 = bits1.begin();
it2 = bits2.begin();
@ -1190,7 +1190,7 @@ namespace smt {
lits.push_back(arg);
}
TRACE("bv",
tout << mk_pp(get_enode(v1)->get_owner(), m) << " = " << mk_pp(get_enode(v2)->get_owner(), m) << " "
tout << mk_pp(get_enode(v1)->get_expr(), m) << " = " << mk_pp(get_enode(v2)->get_expr(), m) << " "
<< ctx.get_scope_level()
<< "\n";
ctx.display_literals_smt2(tout, lits););

6
src/smt/theory_bv.h
View file

@ -145,14 +145,14 @@ namespace smt {
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); }
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_owner()); }
unsigned get_bv_size(enode const * n) const { return m_util.get_bv_size(n->get_expr()); }
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(enode const* n) const { return is_bv(n->get_owner()); }
bool is_bv(enode const* n) const { return is_bv(n->get_expr()); }
bool is_bv(theory_var v) const { return is_bv(get_enode(v)); }
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_owner()); }
bool is_numeral(theory_var v) const { return m_util.is_numeral(get_enode(v)->get_expr()); }
app * mk_bit2bool(app * bv, unsigned idx);
void mk_bits(theory_var v);
friend class mk_atom_trail;

44
src/smt/theory_datatype.cpp
View file

@ -87,7 +87,7 @@ namespace smt {
if (antecedent != null_literal) {
std::function<void(void)> fn = [&]() {
app_ref body(m);
body = m.mk_eq(lhs->get_owner(), rhs);
body = m.mk_eq(lhs->get_expr(), rhs);
body = m.mk_implies(ctx.bool_var2expr(antecedent.var()), body);
log_axiom_instantiation(body, 1, &lhs);
};
@ -95,7 +95,7 @@ namespace smt {
}
if (m.proofs_enabled()) {
literal l(mk_eq(lhs->get_owner(), rhs, true));
literal l(mk_eq(lhs->get_expr(), rhs, true));
ctx.mark_as_relevant(l);
if (antecedent != null_literal) {
literal lits[2] = {l, ~antecedent};
@ -108,12 +108,12 @@ namespace smt {
}
else {
ctx.internalize(rhs, false);
TRACE("datatype", tout << "adding axiom:\n" << mk_pp(lhs->get_owner(), m) << "\n=\n" << mk_pp(rhs, m) << "\n";);
TRACE("datatype", tout << "adding axiom:\n" << pp(lhs, m) << "\n=\n" << mk_pp(rhs, m) << "\n";);
if (antecedent == null_literal) {
ctx.assign_eq(lhs, ctx.get_enode(rhs), eq_justification::mk_axiom());
}
else if (ctx.get_assignment(antecedent) != l_true) {
literal l(mk_eq(lhs->get_owner(), rhs, true));
literal l(mk_eq(lhs->get_expr(), rhs, true));
ctx.mark_as_relevant(l);
ctx.mark_as_relevant(antecedent);
literal lits[2] = {l, ~antecedent};
@ -137,7 +137,7 @@ namespace smt {
where acc_i are the accessors of constructor c.
*/
void theory_datatype::assert_is_constructor_axiom(enode * n, func_decl * c, literal antecedent) {
app* e = n->get_owner();
app* e = n->get_expr();
TRACE("datatype_bug", tout << "creating axiom (= n (c (acc_1 n) ... (acc_m n))) for\n"
<< mk_pp(c, m) << " " << mk_pp(e, m) << "\n";);
m_stats.m_assert_cnstr++;
@ -174,17 +174,17 @@ namespace smt {
vector<std::tuple<enode *, enode *>> used_enodes;
used_enodes.push_back(std::make_tuple(nullptr, n));
for (unsigned i = 0; i < n->get_num_args(); ++i) {
bindings.push_back(n->get_arg(i)->get_owner());
bindings.push_back(n->get_arg(i)->get_expr());
}
unsigned base_id = m.has_trace_stream() && accessors.size() > 0 ? m_util.plugin().get_axiom_base_id(d->get_name()) : 0;
unsigned i = 0;
for (func_decl * acc : accessors) {
app_ref acc_app(m.mk_app(acc, n->get_owner()), m);
app_ref acc_app(m.mk_app(acc, n->get_expr()), m);
enode * arg = n->get_arg(i);
std::function<void(void)> fn = [&]() {
app_ref body(m);
body = m.mk_eq(arg->get_owner(), acc_app);
body = m.mk_eq(arg->get_expr(), acc_app);
log_axiom_instantiation(body, base_id + 3*i, bindings.size(), bindings.c_ptr(), base_id - 3, used_enodes);
};
scoped_trace_stream _st(m, fn);
@ -202,7 +202,7 @@ namespace smt {
SASSERT(m_util.get_recognizer_constructor(r->get_decl()) == c->get_decl());
SASSERT(c->get_root() == r->get_arg(0)->get_root());
TRACE("recognizer_conflict",
tout << mk_ismt2_pp(c->get_owner(), m) << "\n" << mk_ismt2_pp(r->get_owner(), m) << "\n";);
tout << mk_ismt2_pp(c->get_expr(), m) << "\n" << mk_ismt2_pp(r->get_expr(), m) << "\n";);
literal l(ctx.enode2bool_var(r));
SASSERT(ctx.get_assignment(l) == l_false);
l.neg();
@ -223,7 +223,7 @@ namespace smt {
void theory_datatype::assert_update_field_axioms(enode * n) {
m_stats.m_assert_update_field++;
SASSERT(is_update_field(n));
app* own = n->get_owner();
app* own = n->get_expr();
expr* arg1 = own->get_arg(0);
func_decl * upd = n->get_decl();
func_decl * acc = to_func_decl(upd->get_parameter(0).get_ast());
@ -248,7 +248,7 @@ namespace smt {
assert_eq_axiom(arg, acc_own, is_con);
}
// update_field is identity if 'n' is not created by a matching constructor.
app_ref imp(m.mk_implies(m.mk_not(rec_app), m.mk_eq(n->get_owner(), arg1)), m);
app_ref imp(m.mk_implies(m.mk_not(rec_app), m.mk_eq(n->get_expr(), arg1)), m);
assert_eq_axiom(n, arg1, ~is_con);
app_ref n_is_con(m.mk_app(rec, own), m);
@ -335,7 +335,7 @@ namespace smt {
enode * arg = e->get_arg(i);
sort * s = arg->get_sort();
if (m_autil.is_array(s) && m_util.is_datatype(get_array_range(s))) {
app_ref def(m_autil.mk_default(arg->get_owner()), m);
app_ref def(m_autil.mk_default(arg->get_expr()), m);
if (!ctx.e_internalized(def)) {
ctx.internalize(def, false);
}
@ -381,9 +381,9 @@ namespace smt {
// (assert (> (len a) 1)
//
// If the theory variable is not created for 'a', then a wrong model will be generated.
TRACE("datatype", tout << "apply_sort_cnstr: #" << n->get_owner_id() << " " << mk_pp(n->get_owner(), m) << "\n";);
TRACE("datatype", tout << "apply_sort_cnstr: #" << n->get_owner_id() << " " << pp(n, m) << "\n";);
TRACE("datatype_bug",
tout << "apply_sort_cnstr:\n" << mk_pp(n->get_owner(), m) << " ";
tout << "apply_sort_cnstr:\n" << pp(n, m) << " ";
tout << m_util.is_datatype(s) << " ";
if (m_util.is_datatype(s)) tout << "is-infinite: " << s->is_infinite() << " ";
if (m_util.is_datatype(s)) tout << "attached: " << is_attached_to_var(n) << " ";
@ -545,7 +545,7 @@ namespace smt {
// explain the cycle root -> ... -> app -> root
void theory_datatype::occurs_check_explain(enode * app, enode * root) {
TRACE("datatype", tout << "occurs_check_explain " << mk_bounded_pp(app->get_owner(), m) << " <-> " << mk_bounded_pp(root->get_owner(), m) << "\n";);
TRACE("datatype", tout << "occurs_check_explain " << mk_bounded_pp(app->get_expr(), m) << " <-> " << mk_bounded_pp(root->get_expr(), m) << "\n";);
// first: explain that root=v, given that app=cstor(...,v,...)
@ -595,7 +595,7 @@ namespace smt {
return true;
}
// explore `arg` (with parent)
expr* earg = arg->get_owner();
expr* earg = arg->get_expr();
sort* s = earg->get_sort();
if (m_util.is_datatype(s)) {
m_parent.insert(arg->get_root(), parent);
@ -626,7 +626,7 @@ namespace smt {
for (enode* p : th->parent_selects(n)) {
m_array_args.push_back(p);
}
app_ref def(m_autil.mk_default(n->get_owner()), m);
app_ref def(m_autil.mk_default(n->get_expr()), m);
m_array_args.push_back(ctx.get_enode(def));
return m_array_args;
}
@ -780,10 +780,10 @@ namespace smt {
result->add_dependency(arg);
}
TRACE("datatype",
tout << mk_pp(n->get_owner(), m) << "\n";
tout << pp(n, m) << "\n";
tout << "depends on\n";
for (enode* arg : enode::args(d->m_constructor)) {
tout << " " << mk_pp(arg->get_owner(), m) << "\n";
tout << " " << pp(arg, m) << "\n";
});
return result;
}
@ -910,7 +910,7 @@ namespace smt {
// conflict
SASSERT(!lits.empty());
region & reg = ctx.get_region();
TRACE("datatype_conflict", tout << mk_ismt2_pp(recognizer->get_owner(), m) << "\n";
TRACE("datatype_conflict", tout << mk_ismt2_pp(recognizer->get_expr(), m) << "\n";
for (literal l : lits) {
ctx.display_detailed_literal(tout, l) << "\n";
}
@ -927,7 +927,7 @@ namespace smt {
if (!r) {
ptr_vector<func_decl> const & constructors = *m_util.get_datatype_constructors(dt);
func_decl * rec = m_util.get_constructor_is(constructors[unassigned_idx]);
app_ref rec_app(m.mk_app(rec, n->get_owner()), m);
app_ref rec_app(m.mk_app(rec, n->get_expr()), m);
ctx.internalize(rec_app, false);
consequent = literal(ctx.get_bool_var(rec_app));
}
@ -1007,7 +1007,7 @@ namespace smt {
}
}
SASSERT(r != nullptr);
app_ref r_app(m.mk_app(r, n->get_owner()), m);
app_ref r_app(m.mk_app(r, n->get_expr()), m);
TRACE("datatype", tout << "creating split: " << mk_pp(r_app, m) << "\n";);
ctx.internalize(r_app, false);
bool_var bv = ctx.get_bool_var(r_app);

8
src/smt/theory_datatype.h
View file

@ -58,10 +58,10 @@ namespace smt {
bool is_accessor(app * f) const { return m_util.is_accessor(f); }
bool is_update_field(app * f) const { return m_util.is_update_field(f); }
bool is_constructor(enode * n) const { return is_constructor(n->get_owner()); }
bool is_recognizer(enode * n) const { return is_recognizer(n->get_owner()); }
bool is_accessor(enode * n) const { return is_accessor(n->get_owner()); }
bool is_update_field(enode * n) const { return m_util.is_update_field(n->get_owner()); }
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_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()); }
void assert_eq_axiom(enode * lhs, expr * rhs, literal antecedent);
void assert_is_constructor_axiom(enode * n, func_decl * c, literal antecedent);

26
src/smt/theory_dense_diff_logic_def.h
View file

@ -51,7 +51,7 @@ namespace smt {
template<typename Ext>
theory_var theory_dense_diff_logic<Ext>::mk_var(enode * n) {
theory_var v = theory::mk_var(n);
bool is_int = m_autil.is_int(n->get_owner());
bool is_int = m_autil.is_int(n->get_expr());
m_is_int.push_back(is_int);
m_f_targets.push_back(f_target());
for (auto& rows : m_matrix) {
@ -726,7 +726,7 @@ namespace smt {
TRACE("ddl_model",
tout << "ddl model\n";
for (theory_var v = 0; v < num_vars; v++) {
tout << "#" << mk_pp(get_enode(v)->get_owner(), m) << " = " << m_assignment[v] << "\n";
tout << "#" << mk_pp(get_enode(v)->get_expr(), m) << " = " << m_assignment[v] << "\n";
});
}
@ -802,13 +802,13 @@ namespace smt {
int num_vars = get_num_vars();
for (int v = 0; v < num_vars && v < (int)m_assignment.size(); ++v) {
enode * n = get_enode(v);
if (m_autil.is_zero(n->get_owner()) && !m_assignment[v].is_zero()) {
if (m_autil.is_zero(n->get_expr()) && !m_assignment[v].is_zero()) {
numeral val = m_assignment[v];
sort * s = n->get_owner()->get_sort();
sort * s = n->get_expr()->get_sort();
// adjust the value of all variables that have the same sort.
for (int v2 = 0; v2 < num_vars; ++v2) {
enode * n2 = get_enode(v2);
if (n2->get_owner()->get_sort() == s) {
if (n2->get_expr()->get_sort() == s) {
m_assignment[v2] -= val;
}
}
@ -818,7 +818,7 @@ namespace smt {
TRACE("ddl_model",
tout << "ddl model\n";
for (theory_var v = 0; v < num_vars; v++) {
tout << "#" << mk_pp(get_enode(v)->get_owner(), m) << " = " << m_assignment[v] << "\n";
tout << "#" << mk_pp(get_enode(v)->get_expr(), m) << " = " << m_assignment[v] << "\n";
});
}
@ -941,7 +941,7 @@ namespace smt {
}
for (unsigned i = 0; i < num_nodes; ++i) {
enode * n = get_enode(i);
if (m_autil.is_zero(n->get_owner())) {
if (m_autil.is_zero(n->get_expr())) {
S.set_lower(i, mpq_inf(mpq(0), mpq(0)));
S.set_upper(i, mpq_inf(mpq(0), mpq(0)));
break;
@ -1080,19 +1080,19 @@ namespace smt {
expr_ref e(m), f(m), f2(m);
TRACE("opt", tout << "mk_ineq " << v << " " << val << "\n";);
if (t.size() == 1 && t[0].second.is_one()) {
f = get_enode(t[0].first)->get_owner();
f = get_enode(t[0].first)->get_expr();
}
else if (t.size() == 1 && t[0].second.is_minus_one()) {
f = m_autil.mk_uminus(get_enode(t[0].first)->get_owner());
f = m_autil.mk_uminus(get_enode(t[0].first)->get_expr());
}
else if (t.size() == 2 && t[0].second.is_one() && t[1].second.is_minus_one()) {
f = get_enode(t[0].first)->get_owner();
f2 = get_enode(t[1].first)->get_owner();
f = get_enode(t[0].first)->get_expr();
f2 = get_enode(t[1].first)->get_expr();
f = m_autil.mk_sub(f, f2);
}
else if (t.size() == 2 && t[1].second.is_one() && t[0].second.is_minus_one()) {
f = get_enode(t[1].first)->get_owner();
f2 = get_enode(t[0].first)->get_owner();
f = get_enode(t[1].first)->get_expr();
f2 = get_enode(t[0].first)->get_expr();
f = m_autil.mk_sub(f, f2);
}
else {

36
src/smt/theory_diff_logic_def.h
View file

@ -384,11 +384,11 @@ final_check_status theory_diff_logic<Ext>::final_check_eh() {
}
for (enode* n : ctx.enodes()) {
family_id fid = n->get_owner()->get_family_id();
family_id fid = n->get_expr()->get_family_id();
if (fid != get_family_id() &&
fid != m.get_basic_family_id() &&
!is_uninterp_const(n->get_owner())) {
TRACE("arith", tout << mk_pp(n->get_owner(), m) << "\n";);
!is_uninterp_const(n->get_expr())) {
TRACE("arith", tout << mk_pp(n->get_expr(), m) << "\n";);
return FC_GIVEUP;
}
}
@ -607,8 +607,8 @@ void theory_diff_logic<Ext>::new_edge(dl_var src, dl_var dst, unsigned num_edges
}
enode* e1 = get_enode(src);
enode* e2 = get_enode(dst);
expr* n1 = e1->get_owner();
expr* n2 = e2->get_owner();
expr* n1 = e1->get_expr();
expr* n2 = e2->get_expr();
bool is_int = m_util.is_int(n1);
rational num = w.get_rational().to_rational();
@ -821,7 +821,7 @@ theory_var theory_diff_logic<Ext>::mk_var(enode* n) {
TRACE("diff_logic_vars", tout << "mk_var: " << v << "\n";);
m_graph.init_var(v);
ctx.attach_th_var(n, this, v);
set_sort(n->get_owner());
set_sort(n->get_expr());
return v;
}
@ -938,12 +938,12 @@ model_value_proc * theory_diff_logic<Ext>::mk_value(enode * n, model_generator &
theory_var v = n->get_th_var(get_id());
SASSERT(v != null_theory_var);
rational num;
if (!m_util.is_numeral(n->get_owner(), num)) {
if (!m_util.is_numeral(n->get_expr(), num)) {
numeral val = m_graph.get_assignment(v);
num = val.get_rational().to_rational() + m_delta * val.get_infinitesimal().to_rational();
}
TRACE("arith", tout << mk_pp(n->get_owner(), m) << " |-> " << num << "\n";);
bool is_int = m_util.is_int(n->get_owner());
TRACE("arith", tout << mk_pp(n->get_expr(), m) << " |-> " << num << "\n";);
bool is_int = m_util.is_int(n->get_expr());
if (is_int && !num.is_int())
throw default_exception("difference logic solver was used on mixed int/real problem");
return alloc(expr_wrapper_proc, m_factory->mk_num_value(num, is_int));
@ -983,7 +983,7 @@ theory_var theory_diff_logic<Ext>::expand(bool pos, theory_var v, rational & k)
enode* e = get_enode(v);
rational r;
for (;;) {
app* n = e->get_owner();
app* n = e->get_expr();
if (m_util.is_add(n) && n->get_num_args() == 2) {
app* x = to_app(n->get_arg(0));
app* y = to_app(n->get_arg(1));
@ -1033,8 +1033,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* s1 = get_enode(s)->get_owner();
app* t1 = get_enode(t)->get_owner();
app* s1 = get_enode(s)->get_expr();
app* t1 = get_enode(t)->get_expr();
s2 = m_util.mk_sub(t1, s1);
t2 = m_util.mk_numeral(k, s2->get_sort());
// t1 - s1 = k
@ -1344,19 +1344,19 @@ expr_ref theory_diff_logic<Ext>::mk_ineq(theory_var v, inf_eps const& val, bool
objective_term const& t = m_objectives[v];
expr_ref e(m), f(m), f2(m);
if (t.size() == 1 && t[0].second.is_one()) {
f = get_enode(t[0].first)->get_owner();
f = get_enode(t[0].first)->get_expr();
}
else if (t.size() == 1 && t[0].second.is_minus_one()) {
f = m_util.mk_uminus(get_enode(t[0].first)->get_owner());
f = m_util.mk_uminus(get_enode(t[0].first)->get_expr());
}
else if (t.size() == 2 && t[0].second.is_one() && t[1].second.is_minus_one()) {
f = get_enode(t[0].first)->get_owner();
f2 = get_enode(t[1].first)->get_owner();
f = get_enode(t[0].first)->get_expr();
f2 = get_enode(t[1].first)->get_expr();
f = m_util.mk_sub(f, f2);
}
else if (t.size() == 2 && t[1].second.is_one() && t[0].second.is_minus_one()) {
f = get_enode(t[1].first)->get_owner();
f2 = get_enode(t[0].first)->get_owner();
f = get_enode(t[1].first)->get_expr();
f2 = get_enode(t[0].first)->get_expr();
f = m_util.mk_sub(f, f2);
}
else {

6
src/smt/theory_dl.cpp
View file

@ -79,12 +79,12 @@ namespace smt {
app * mk_value(smt::model_generator & mg, expr_ref_vector const & ) override {
smt::context& ctx = m_th.get_context();
app* result = nullptr;
expr* n = m_node->get_owner();
expr* n = m_node->get_expr();
sort* s = n->get_sort();
func_decl* r, *v;
m_th.get_rep(s, r, v);
app_ref rep_of(m_th.m());
rep_of = m_th.m().mk_app(r, m_node->get_owner());
rep_of = m_th.m().mk_app(r, m_node->get_expr());
theory_id bv_id = m_th.m().mk_family_id("bv");
theory_bv* th_bv = dynamic_cast<theory_bv*>(ctx.get_theory(bv_id));
SASSERT(th_bv);
@ -166,7 +166,7 @@ namespace smt {
}
void apply_sort_cnstr(enode * n, sort * s) override {
app* term = n->get_owner();
app* term = n->get_expr();
if (u().is_finite_sort(term)) {
mk_rep(term);
}

52
src/smt/theory_fpa.cpp
View file

@ -228,7 +228,7 @@ namespace smt {
void theory_fpa::attach_new_th_var(enode * n) {
theory_var v = mk_var(n);
ctx.attach_th_var(n, this, v);
TRACE("t_fpa", tout << "new theory var: " << mk_ismt2_pp(n->get_owner(), m) << " := " << v << "\n";);
TRACE("t_fpa", tout << "new theory var: " << mk_ismt2_pp(n->get_expr(), m) << " := " << v << "\n";);
}
bool theory_fpa::internalize_atom(app * atom, bool gate_ctx) {
@ -290,13 +290,13 @@ namespace smt {
}
void theory_fpa::apply_sort_cnstr(enode * n, sort * s) {
TRACE("t_fpa", tout << "apply sort cnstr for: " << mk_ismt2_pp(n->get_owner(), m) << "\n";);
TRACE("t_fpa", tout << "apply sort cnstr for: " << mk_ismt2_pp(n->get_expr(), m) << "\n";);
SASSERT(s->get_family_id() == get_family_id());
SASSERT(m_fpa_util.is_float(s) || m_fpa_util.is_rm(s));
SASSERT(m_fpa_util.is_float(n->get_owner()) || m_fpa_util.is_rm(n->get_owner()));
SASSERT(n->get_owner()->get_decl()->get_range() == s);
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);
app * owner = n->get_owner();
app * owner = n->get_expr();
if (!is_attached_to_var(n)) {
attach_new_th_var(n);
@ -322,13 +322,13 @@ namespace smt {
enode * e_y = get_enode(y);
TRACE("t_fpa", tout << "new eq: " << x << " = " << y << std::endl;
tout << mk_ismt2_pp(e_x->get_owner(), m) << std::endl << " = " << std::endl <<
mk_ismt2_pp(e_y->get_owner(), m) << std::endl;);
tout << mk_ismt2_pp(e_x->get_expr(), m) << std::endl << " = " << std::endl <<
mk_ismt2_pp(e_y->get_expr(), m) << std::endl;);
fpa_util & fu = m_fpa_util;
expr * xe = e_x->get_owner();
expr * ye = e_y->get_owner();
expr * xe = e_x->get_expr();
expr * ye = e_y->get_expr();
if (m_fpa_util.is_bvwrap(xe) || m_fpa_util.is_bvwrap(ye))
return;
@ -361,13 +361,13 @@ namespace smt {
enode * e_y = get_enode(y);
TRACE("t_fpa", tout << "new diseq: " << x << " != " << y << std::endl;
tout << mk_ismt2_pp(e_x->get_owner(), m) << std::endl << " != " << std::endl <<
mk_ismt2_pp(e_y->get_owner(), m) << std::endl;);
tout << mk_ismt2_pp(e_x->get_expr(), m) << std::endl << " != " << std::endl <<
mk_ismt2_pp(e_y->get_expr(), m) << std::endl;);
fpa_util & fu = m_fpa_util;
expr * xe = e_x->get_owner();
expr * ye = e_y->get_owner();
expr * xe = e_x->get_expr();
expr * ye = e_y->get_expr();
if (m_fpa_util.is_bvwrap(xe) || m_fpa_util.is_bvwrap(ye))
return;
@ -532,11 +532,11 @@ namespace smt {
}
model_value_proc * theory_fpa::mk_value(enode * n, model_generator & mg) {
TRACE("t_fpa", tout << "mk_value for: " << mk_ismt2_pp(n->get_owner(), m) <<
" (sort " << mk_ismt2_pp(n->get_owner()->get_sort(), m) << ")\n";);
TRACE("t_fpa", tout << "mk_value for: " << mk_ismt2_pp(n->get_expr(), m) <<
" (sort " << mk_ismt2_pp(n->get_expr()->get_sort(), m) << ")\n";);
app_ref owner(m);
owner = get_ite_value(n->get_owner());
owner = get_ite_value(n->get_expr());
// If the owner is not internalized, it doesn't have an enode associated.
SASSERT(ctx.e_internalized(owner));
@ -571,9 +571,9 @@ namespace smt {
vp->add_dependency(ctx.get_enode(a1));
vp->add_dependency(ctx.get_enode(a2));
TRACE("t_fpa_detail", tout << "Depends on: " <<
mk_ismt2_pp(a0, m) << " eq. cls. #" << get_enode(a0)->get_root()->get_owner()->get_id() << std::endl <<
mk_ismt2_pp(a1, m) << " eq. cls. #" << get_enode(a1)->get_root()->get_owner()->get_id() << std::endl <<
mk_ismt2_pp(a2, m) << " eq. cls. #" << get_enode(a2)->get_root()->get_owner()->get_id() << std::endl;);
mk_ismt2_pp(a0, m) << " eq. cls. #" << get_enode(a0)->get_root()->get_expr()->get_id() << std::endl <<
mk_ismt2_pp(a1, m) << " eq. cls. #" << get_enode(a1)->get_root()->get_expr()->get_id() << std::endl <<
mk_ismt2_pp(a2, m) << " eq. cls. #" << get_enode(a2)->get_root()->get_expr()->get_id() << std::endl;);
res = vp;
}
else if (m_fpa_util.is_bv2rm(owner)) {
@ -583,7 +583,7 @@ namespace smt {
fpa_rm_value_proc * vp = alloc(fpa_rm_value_proc, this);
vp->add_dependency(ctx.get_enode(a0));
TRACE("t_fpa_detail", tout << "Depends on: " <<
mk_ismt2_pp(a0, m) << " eq. cls. #" << get_enode(a0)->get_root()->get_owner()->get_id() << std::endl;);
mk_ismt2_pp(a0, m) << " eq. cls. #" << get_enode(a0)->get_root()->get_expr()->get_id() << std::endl;);
res = vp;
}
else if (ctx.e_internalized(wrapped)) {
@ -598,7 +598,7 @@ namespace smt {
fpa_value_proc * vp = alloc(fpa_value_proc, this, ebits, sbits);
enode * en = ctx.get_enode(wrapped);
vp->add_dependency(en);
TRACE("t_fpa_detail", tout << "Depends on: " << mk_ismt2_pp(wrapped, m) << " eq. cls. #" << en->get_root()->get_owner()->get_id() << std::endl;);
TRACE("t_fpa_detail", tout << "Depends on: " << mk_ismt2_pp(wrapped, m) << " eq. cls. #" << en->get_root()->get_expr()->get_id() << std::endl;);
res = vp;
}
}
@ -646,7 +646,7 @@ namespace smt {
if (v != -1) {
if (first) out << "fpa theory variables:" << std::endl;
out << v << " -> " <<
mk_ismt2_pp(n->get_owner(), m) << std::endl;
mk_ismt2_pp(n->get_expr(), m) << std::endl;
first = false;
}
}
@ -657,20 +657,20 @@ namespace smt {
for (enode * n : ctx.enodes()) {
theory_var v = n->get_th_var(m_bv_util.get_family_id());
if (v != -1) out << v << " -> " <<
mk_ismt2_pp(n->get_owner(), m) << std::endl;
mk_ismt2_pp(n->get_expr(), m) << std::endl;
}
out << "arith theory variables:" << std::endl;
for (enode* n : ctx.enodes()) {
theory_var v = n->get_th_var(m_arith_util.get_family_id());
if (v != -1) out << v << " -> " <<
mk_ismt2_pp(n->get_owner(), m) << std::endl;
mk_ismt2_pp(n->get_expr(), m) << std::endl;
}
out << "equivalence classes:\n";
for (enode * n : ctx.enodes()) {
expr * e = n->get_owner();
expr * r = n->get_root()->get_owner();
expr * e = n->get_expr();
expr * r = n->get_root()->get_expr();
out << r->get_id() << " --> " << mk_ismt2_pp(e, m) << std::endl;
}
}

62
src/smt/theory_lra.cpp
View file

@ -239,12 +239,12 @@ class theory_lra::imp {
theory_id get_id() const { return th.get_id(); }
theory_arith_params const& params() const { return ctx().get_fparams(); }
bool is_int(theory_var v) const { return is_int(get_enode(v)); }
bool is_int(enode* n) const { return a.is_int(n->get_owner()); }
bool is_int(enode* n) const { return a.is_int(n->get_expr()); }
bool is_real(theory_var v) const { return is_real(get_enode(v)); }
bool is_real(enode* n) const { return a.is_real(n->get_owner()); }
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(expr* e) const { return ctx().get_enode(e); }
expr* get_owner(theory_var v) const { return get_enode(v)->get_owner(); }
expr* get_owner(theory_var v) const { return get_enode(v)->get_expr(); }
lpvar add_const(int c, lpvar& var, bool is_int) {
if (var != UINT_MAX) {
@ -717,8 +717,8 @@ class theory_lra::imp {
}
TRACE("arith",
{
expr* o1 = get_enode(v1)->get_owner();
expr* o2 = get_enode(v2)->get_owner();
expr* o1 = get_enode(v1)->get_expr();
expr* o2 = get_enode(v2)->get_expr();
tout << "v" << v1 << " = " << "v" << v2 << ": "
<< mk_pp(o1, m) << " = " << mk_pp(o2, m) << "\n";
});
@ -1046,7 +1046,7 @@ public:
}
void apply_sort_cnstr(enode* n, sort*) {
TRACE("arith", tout << "sort constraint: " << mk_pp(n->get_owner(), m) << "\n";);
TRACE("arith", tout << "sort constraint: " << pp(n, m) << "\n";);
#if 0
if (!th.is_attached_to_var(n)) {
mk_var(n->get_owner());
@ -1201,9 +1201,9 @@ public:
/// abs(r) > r >= 0
void assert_idiv_mod_axioms(theory_var u, theory_var v, theory_var w, rational const& r) {
app_ref term(m);
term = a.mk_mul(a.mk_numeral(r, true), get_enode(w)->get_owner());
term = a.mk_add(get_enode(v)->get_owner(), term);
term = a.mk_sub(get_enode(u)->get_owner(), term);
term = a.mk_mul(a.mk_numeral(r, true), get_enode(w)->get_expr());
term = a.mk_add(get_enode(v)->get_expr(), term);
term = a.mk_sub(get_enode(u)->get_expr(), term);
theory_var z = internalize_def(term);
lpvar zi = register_theory_var_in_lar_solver(z);
lpvar vi = register_theory_var_in_lar_solver(v);
@ -1502,8 +1502,8 @@ public:
}
enode* n2 = get_enode(other);
if (n1->get_root() != n2->get_root()) {
TRACE("arith", tout << mk_pp(n1->get_owner(), m) << " = " << mk_pp(n2->get_owner(), m) << "\n";
tout << mk_pp(n1->get_owner(), m) << " = " << mk_pp(n2->get_owner(), m) << "\n";
TRACE("arith", tout << pp(n1, m) << " = " << pp(n2, m) << "\n";
tout << pp(n1, m) << " = " << pp(n2, m) << "\n";
tout << "v" << v << " = " << "v" << other << "\n";);
m_assume_eq_candidates.push_back(std::make_pair(v, other));
num_candidates++;
@ -1650,7 +1650,7 @@ public:
rational lc = denominator(k);
for (auto const& kv : coeffs) {
theory_var w = kv.m_key;
expr* o = get_enode(w)->get_owner();
expr* o = get_enode(w)->get_expr();
is_int = a.is_int(o);
if (!is_int) break;
lc = lcm(lc, denominator(kv.m_value));
@ -2076,7 +2076,7 @@ public:
}
else {
for (enode * parent : r->get_const_parents()) {
if (a.is_underspecified(parent->get_owner())) {
if (a.is_underspecified(parent->get_expr())) {
return true;
}
}
@ -2253,7 +2253,7 @@ public:
lpvar vi = be.m_j;
if (lp::tv::is_term(vi))
return;
expr_ref w(get_enode(v)->get_owner(), m);
expr_ref w(get_enode(v)->get_expr(), m);
if (a.is_add(w) || a.is_numeral(w) || m.is_ite(w))
return;
literal bound = null_literal;
@ -2297,8 +2297,8 @@ public:
return;
if (!ctx().is_shared(n1) || !ctx().is_shared(n2))
return;
expr* e1 = n1->get_owner();
expr* e2 = n2->get_owner();
expr* e1 = n1->get_expr();
expr* e2 = n2->get_expr();
if (e1->get_sort() != e2->get_sort())
return;
if (m.is_ite(e1) || m.is_ite(e2))
@ -3077,9 +3077,9 @@ public:
for (auto c : m_core)
ctx().display_detailed_literal(tout, c) << "\n";
for (auto e : m_eqs)
tout << mk_pp(e.first->get_owner(), m) << " = " << mk_pp(e.second->get_owner(), m) << "\n";
tout << pp(e.first, m) << " = " << pp(e.second, m) << "\n";
tout << " ==> ";
tout << mk_pp(x->get_owner(), m) << " = " << mk_pp(y->get_owner(), m) << "\n";
tout << pp(x, m) << " = " << pp(y, m) << "\n";
);
// parameters are TBD.
@ -3189,7 +3189,7 @@ public:
}
else {
for (auto const& eq : m_eqs) {
m_core.push_back(th.mk_eq(eq.first->get_owner(), eq.second->get_owner(), false));
m_core.push_back(th.mk_eq(eq.first->get_expr(), eq.second->get_expr(), false));
}
for (literal & c : m_core) {
c.neg();
@ -3287,7 +3287,7 @@ public:
model_value_proc * mk_value(enode * n, model_generator & mg) {
theory_var v = n->get_th_var(get_id());
expr* o = n->get_owner();
expr* o = n->get_expr();
if (use_nra_model() && lp().external_to_local(v) != lp::null_lpvar) {
anum const& an = nl_value(v, *m_a1);
if (a.is_int(o) && !m_nla->am().is_int(an)) {
@ -3309,7 +3309,7 @@ public:
if (!is_registered_var(v)) return false;
lpvar vi = get_lpvar(v);
if (lp().has_value(vi, val)) {
TRACE("arith", tout << expr_ref(n->get_owner(), m) << " := " << val << "\n";);
TRACE("arith", tout << expr_ref(n->get_expr(), m) << " := " << val << "\n";);
if (is_int(n) && !val.is_int()) return false;
return true;
}
@ -3433,7 +3433,7 @@ public:
if (params().m_arith_mode == arith_solver_id::AS_NEW_ARITH) return true;
context nctx(m, ctx().get_fparams(), ctx().get_params());
add_background(nctx);
nctx.assert_expr(m.mk_not(m.mk_eq(x->get_owner(), y->get_owner())));
nctx.assert_expr(m.mk_not(m.mk_eq(x->get_expr(), y->get_expr())));
cancel_eh<reslimit> eh(m.limit());
scoped_timer timer(1000, &eh);
return l_true != nctx.check();
@ -3446,7 +3446,7 @@ public:
nctx.assert_expr(tmp);
}
for (auto const& eq : m_eqs) {
nctx.assert_expr(m.mk_eq(eq.first->get_owner(), eq.second->get_owner()));
nctx.assert_expr(m.mk_eq(eq.first->get_expr(), eq.second->get_expr()));
}
}
@ -3508,7 +3508,7 @@ public:
expr_ref mk_gt(theory_var v) {
lp::impq val = get_ivalue(v);
expr* obj = get_enode(v)->get_owner();
expr* obj = get_enode(v)->get_expr();
rational r = val.x;
expr_ref e(m);
if (a.is_int(obj->get_sort())) {
@ -3571,7 +3571,7 @@ public:
expr_ref_vector args(m);
for (auto const& kv : coeffs) {
theory_var w = kv.m_key;
expr* o = get_enode(w)->get_owner();
expr* o = get_enode(w)->get_expr();
if (kv.m_value.is_zero()) {
// continue
}
@ -3618,13 +3618,13 @@ public:
app_ref mk_obj(theory_var v) {
auto t = get_tv(v);
bool is_int = a.is_int(get_enode(v)->get_owner());
bool is_int = a.is_int(get_enode(v)->get_expr());
if (t.is_term()) {
return mk_term(lp().get_term(t), is_int);
}
else {
// theory_var w = lp().external_to_local(vi);
return app_ref(get_enode(v)->get_owner(), m);
return app_ref(get_enode(v)->get_expr(), m);
}
}
@ -3632,7 +3632,7 @@ public:
rational r = val.get_rational();
bool is_strict = val.get_infinitesimal().is_pos();
app_ref b(m);
bool is_int = a.is_int(get_enode(v)->get_owner());
bool is_int = a.is_int(get_enode(v)->get_expr());
TRACE("arith", display(tout << "v" << v << "\n"););
if (is_strict) {
b = a.mk_le(mk_obj(v), a.mk_numeral(r, is_int));
@ -3708,13 +3708,13 @@ public:
break;
}
case equality_source:
out << mk_pp(m_equalities[idx].first->get_owner(), m) << " = "
<< mk_pp(m_equalities[idx].second->get_owner(), m) << "\n";
out << pp(m_equalities[idx].first, m) << " = "
<< pp(m_equalities[idx].second, m) << "\n";
break;
case definition_source: {
theory_var v = m_definitions[idx];
if (v != null_theory_var)
out << "def: v" << v << " := " << mk_pp(th.get_enode(v)->get_owner(), m) << "\n";
out << "def: v" << v << " := " << pp(th.get_enode(v), m) << "\n";
break;
}
case null_source:

2
src/smt/theory_pb.cpp
View file

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

4
src/smt/theory_recfun.h
View file

@ -63,8 +63,8 @@ namespace smt {
bool is_defined(app * f) const { return u().is_defined(f); }
bool is_case_pred(app * f) const { return u().is_case_pred(f); }
bool is_defined(enode * e) const { return is_defined(e->get_owner()); }
bool is_case_pred(enode * e) const { return is_case_pred(e->get_owner()); }
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()); }
void activate_guard(expr* guard, expr_ref_vector const& guards);

54
src/smt/theory_seq.cpp
View file

@ -555,7 +555,7 @@ bool theory_seq::check_extensionality() {
unsigned_vector seqs;
for (unsigned v = 0; v < sz; ++v) {
enode* n1 = get_enode(v);
expr* o1 = n1->get_owner();
expr* o1 = n1->get_expr();
if (n1 != n1->get_root()) {
continue;
}
@ -567,7 +567,7 @@ bool theory_seq::check_extensionality() {
}
for (theory_var v : seqs) {
enode* n2 = get_enode(v);
expr* o2 = n2->get_owner();
expr* o2 = n2->get_expr();
if (o1->get_sort() != o2->get_sort()) {
continue;
}
@ -575,7 +575,7 @@ bool theory_seq::check_extensionality() {
continue;
}
expr_ref e2(m);
if (!canonize(n2->get_owner(), dep, e2)) {
if (!canonize(n2->get_expr(), dep, e2)) {
return false;
}
m_new_eqs.reset();
@ -783,13 +783,13 @@ bool theory_seq::propagate_eq(dependency* dep, enode* n1, enode* n2) {
enode_pair_vector eqs;
linearize(dep, eqs, lits);
TRACE("seq_verbose",
tout << "assert: " << mk_bounded_pp(n1->get_owner(), m) << " = " << mk_bounded_pp(n2->get_owner(), m) << " <-\n";
tout << "assert: " << mk_bounded_pp(n1->get_expr(), m) << " = " << mk_bounded_pp(n2->get_expr(), m) << " <-\n";
display_deps(tout, dep);
);
TRACE("seq",
tout << "assert: "
<< mk_bounded_pp(n1->get_owner(), m) << " = " << mk_bounded_pp(n2->get_owner(), m) << " <-\n"
<< mk_bounded_pp(n1->get_expr(), m) << " = " << mk_bounded_pp(n2->get_expr(), m) << " <-\n"
<< lits << "\n";
);
@ -799,7 +799,7 @@ bool theory_seq::propagate_eq(dependency* dep, enode* n1, enode* n2) {
get_id(), ctx.get_region(), lits.size(), lits.c_ptr(), eqs.size(), eqs.c_ptr(), n1, n2));
{
std::function<expr*(void)> fn = [&]() { return m.mk_eq(n1->get_owner(), n2->get_owner()); };
std::function<expr*(void)> fn = [&]() { return m.mk_eq(n1->get_expr(), n2->get_expr()); };
scoped_trace_stream _sts(*this, fn);
ctx.assign_eq(n1, n2, eq_justification(js));
}
@ -823,8 +823,8 @@ bool theory_seq::propagate_eq(dependency* dep, literal lit, expr* e1, expr* e2,
}
void theory_seq::enforce_length_coherence(enode* n1, enode* n2) {
expr* o1 = n1->get_owner();
expr* o2 = n2->get_owner();
expr* o1 = n1->get_expr();
expr* o2 = n2->get_expr();
if (m_util.str.is_concat(o1) && m_util.str.is_concat(o2)) {
return;
}
@ -1555,7 +1555,7 @@ bool theory_seq::add_length_to_eqc(expr* e) {
enode* n1 = n;
bool change = false;
do {
expr* o = n->get_owner();
expr* o = n->get_expr();
if (!has_length(o)) {
expr_ref len(m_util.str.mk_length(o), m);
enque_axiom(len);
@ -1701,8 +1701,8 @@ std::ostream& theory_seq::display_deps(std::ostream& out, literal_vector const&
for (auto const& eq : eqs) {
if (eq.first->get_root() != eq.second->get_root())
out << "invalid: ";
out << " (= " << mk_bounded_pp(eq.first->get_owner(), m, 2)
<< "\n " << mk_bounded_pp(eq.second->get_owner(), m, 2)
out << " (= " << mk_bounded_pp(eq.first->get_expr(), m, 2)
<< "\n " << mk_bounded_pp(eq.second->get_expr(), m, 2)
<< ")\n";
}
for (literal l : lits) {
@ -1714,8 +1714,8 @@ std::ostream& theory_seq::display_deps(std::ostream& out, literal_vector const&
std::ostream& theory_seq::display_deps_smt2(std::ostream& out, literal_vector const& lits, enode_pair_vector const& eqs) const {
params_ref p;
for (auto const& eq : eqs) {
out << " (= " << mk_pp(eq.first->get_owner(), m)
<< "\n " << mk_pp(eq.second->get_owner(), m)
out << " (= " << pp(eq.first, m)
<< "\n " << pp(eq.second, m)
<< ")\n";
}
for (literal l : lits) {
@ -1911,7 +1911,7 @@ public:
th.m_str_rewrite(result);
}
th.m_factory->add_trail(result);
TRACE("seq", tout << mk_pp(m_node->get_owner(), th.m) << " -> " << result << "\n";);
TRACE("seq", tout << pp(m_node, th.m) << " -> " << result << "\n";);
return to_app(result);
}
};
@ -1933,7 +1933,7 @@ app* theory_seq::get_ite_value(expr* e) {
}
model_value_proc * theory_seq::mk_value(enode * n, model_generator & mg) {
app* e = n->get_owner();
app* e = n->get_expr();
TRACE("seq", tout << mk_pp(e, m) << "\n";);
// Shortcut for well-founded values to avoid some quadratic overhead
@ -2241,11 +2241,11 @@ void theory_seq::validate_assign(literal lit, enode_pair_vector const& eqs, lite
void theory_seq::validate_assign_eq(enode* a, enode* b, enode_pair_vector const& eqs, literal_vector const& lits) {
IF_VERBOSE(10, display_deps(verbose_stream() << "; assign-eq\n", lits, eqs);
verbose_stream() << "(not (= " << mk_bounded_pp(a->get_owner(), m)
<< " " << mk_bounded_pp(b->get_owner(), m) << "))\n");
verbose_stream() << "(not (= " << mk_bounded_pp(a->get_expr(), m)
<< " " << mk_bounded_pp(b->get_expr(), m) << "))\n");
if (get_fparams().m_seq_validate) {
expr_ref_vector fmls(m);
fmls.push_back(m.mk_not(m.mk_eq(a->get_owner(), b->get_owner())));
fmls.push_back(m.mk_not(m.mk_eq(a->get_expr(), b->get_expr())));
validate_fmls(eqs, lits, fmls);
}
}
@ -2261,7 +2261,7 @@ void theory_seq::validate_fmls(enode_pair_vector const& eqs, literal_vector cons
fmls.push_back(fml);
}
for (auto const& p : eqs) {
fmls.push_back(m.mk_eq(p.first->get_owner(), p.second->get_owner()));
fmls.push_back(m.mk_eq(p.first->get_expr(), p.second->get_expr()));
}
TRACE("seq", tout << fmls << "\n";);
@ -2287,7 +2287,7 @@ void theory_seq::validate_fmls(enode_pair_vector const& eqs, literal_vector cons
}
theory_var theory_seq::mk_var(enode* n) {
expr* o = n->get_owner();
expr* o = n->get_expr();
if (!m_util.is_seq(o) && !m_util.is_re(o))
return null_theory_var;
@ -2962,8 +2962,8 @@ void theory_seq::assign_eh(bool_var v, bool is_true) {
void theory_seq::new_eq_eh(theory_var v1, theory_var v2) {
enode* n1 = get_enode(v1);
enode* n2 = get_enode(v2);
expr* o1 = n1->get_owner();
expr* o2 = n2->get_owner();
expr* o1 = n1->get_expr();
expr* o2 = n2->get_expr();
if (!m_util.is_seq(o1) && !m_util.is_re(o1))
return;
if (m_util.is_re(o1)) {
@ -2976,8 +2976,8 @@ void theory_seq::new_eq_eh(theory_var v1, theory_var v2) {
}
void theory_seq::new_eq_eh(dependency* deps, enode* n1, enode* n2) {
expr* e1 = n1->get_owner();
expr* e2 = n2->get_owner();
expr* e1 = n1->get_expr();
expr* e2 = n2->get_expr();
TRACE("seq", tout << mk_bounded_pp(e1, m) << " = " << mk_bounded_pp(e2, m) << "\n";);
if (n1 != n2 && m_util.is_seq(e1)) {
theory_var v1 = n1->get_th_var(get_id());
@ -3003,11 +3003,11 @@ void theory_seq::new_eq_eh(dependency* deps, enode* n1, enode* n2) {
void theory_seq::new_diseq_eh(theory_var v1, theory_var v2) {
enode* n1 = get_enode(v1);
enode* n2 = get_enode(v2);
expr_ref e1(n1->get_owner(), m);
expr_ref e2(n2->get_owner(), m);
expr_ref e1(n1->get_expr(), m);
expr_ref e2(n2->get_expr(), m);
if (n1->get_root() == n2->get_root())
return;
if (m_util.is_re(n1->get_owner())) {
if (m_util.is_re(n1->get_expr())) {
m_regex.propagate_ne(e1, e2);
return;
}

8
src/smt/theory_special_relations.cpp
View file

@ -532,8 +532,8 @@ namespace smt {
r.m_graph.find_shortest_zero_edge_path(i, j, timestamp, r);
r.m_graph.find_shortest_zero_edge_path(j, i, timestamp, r);
literal_vector const& lits = r.m_explanation;
TRACE("special_relations", ctx.display_literals_verbose(tout << mk_pp(x->get_owner(), m) << " = " << mk_pp(y->get_owner(), m) << "\n", lits) << "\n";);
IF_VERBOSE(20, ctx.display_literals_verbose(verbose_stream() << mk_pp(x->get_owner(), m) << " = " << mk_pp(y->get_owner(), m) << "\n", lits) << "\n";);
TRACE("special_relations", ctx.display_literals_verbose(tout << mk_pp(x->get_expr(), m) << " = " << mk_pp(y->get_expr(), m) << "\n", lits) << "\n";);
IF_VERBOSE(20, ctx.display_literals_verbose(verbose_stream() << mk_pp(x->get_expr(), m) << " = " << mk_pp(y->get_expr(), m) << "\n", lits) << "\n";);
eq_justification js(ctx.mk_justification(ext_theory_eq_propagation_justification(get_id(), ctx.get_region(), lits.size(), lits.c_ptr(), 0, nullptr,
x, y)));
ctx.assign_eq(x, y, js);
@ -945,8 +945,8 @@ namespace smt {
atom& a = *ap;
if (!a.phase()) continue;
SASSERT(ctx.get_assignment(a.var()) == l_true);
expr* x = get_enode(a.v1())->get_root()->get_owner();
expr* y = get_enode(a.v2())->get_root()->get_owner();
expr* x = get_enode(a.v1())->get_root()->get_expr();
expr* y = get_enode(a.v2())->get_root()->get_expr();
expr* cb = connected_body;
expr* args[5] = { x, y, A, S, cb };
connected_body = m.mk_app(nextf, 5, args);

110
src/smt/theory_str.cpp
View file

@ -315,8 +315,8 @@ namespace smt {
}
theory_var theory_str::mk_var(enode* n) {
TRACE("str", tout << "mk_var for " << mk_pp(n->get_owner(), get_manager()) << std::endl;);
if (!(n->get_owner()->get_sort() == u.str.mk_string_sort())) {
TRACE("str", tout << "mk_var for " << mk_pp(n->get_expr(), get_manager()) << std::endl;);
if (!(n->get_expr()->get_sort() == u.str.mk_string_sort())) {
return null_theory_var;
}
if (is_attached_to_var(n)) {
@ -809,7 +809,7 @@ namespace smt {
unsigned start_count = m_library_aware_axiom_todo.size();
ptr_vector<enode> axioms_tmp(m_library_aware_axiom_todo);
for (auto const& e : axioms_tmp) {
app * a = e->get_owner();
app * a = e->get_expr();
if (u.str.is_stoi(a)) {
instantiate_axiom_str_to_int(e);
} else if (u.str.is_itos(a)) {
@ -837,7 +837,7 @@ namespace smt {
} else if (u.str.is_to_code(a)) {
instantiate_axiom_str_to_code(e);
} else {
TRACE("str", tout << "BUG: unhandled library-aware term " << mk_pp(e->get_owner(), get_manager()) << std::endl;);
TRACE("str", tout << "BUG: unhandled library-aware term " << mk_pp(e->get_expr(), get_manager()) << std::endl;);
NOT_IMPLEMENTED_YET();
}
}
@ -884,7 +884,7 @@ namespace smt {
*/
void theory_str::try_eval_concat(enode * cat) {
app * a_cat = cat->get_owner();
app * a_cat = cat->get_expr();
SASSERT(u.str.is_concat(a_cat));
ast_manager & m = get_manager();
@ -934,7 +934,7 @@ namespace smt {
*/
void theory_str::instantiate_concat_axiom(enode * cat) {
ast_manager & m = get_manager();
app * a_cat = cat->get_owner();
app * a_cat = cat->get_expr();
TRACE("str", tout << "instantiating concat axiom for " << mk_ismt2_pp(a_cat, m) << std::endl;);
if (!u.str.is_concat(a_cat)) {
return;
@ -979,13 +979,13 @@ namespace smt {
void theory_str::instantiate_basic_string_axioms(enode * str) {
ast_manager & m = get_manager();
TRACE("str", tout << "set up basic string axioms on " << mk_pp(str->get_owner(), m) << std::endl;);
TRACE("str", tout << "set up basic string axioms on " << mk_pp(str->get_expr(), m) << std::endl;);
{
sort * a_sort = str->get_owner()->get_sort();
sort * a_sort = str->get_expr()->get_sort();
sort * str_sort = u.str.mk_string_sort();
if (a_sort != str_sort) {
TRACE("str", tout << "WARNING: not setting up string axioms on non-string term " << mk_pp(str->get_owner(), m) << std::endl;);
TRACE("str", tout << "WARNING: not setting up string axioms on non-string term " << mk_pp(str->get_expr(), m) << std::endl;);
return;
}
}
@ -997,7 +997,7 @@ namespace smt {
}
// generate a stronger axiom for constant strings
app * a_str = str->get_owner();
app * a_str = str->get_expr();
if (u.str.is_string(a_str)) {
expr_ref len_str(m);
@ -1005,7 +1005,7 @@ namespace smt {
SASSERT(len_str);
zstring strconst;
u.str.is_string(str->get_owner(), strconst);
u.str.is_string(str->get_expr(), strconst);
TRACE("str", tout << "instantiating constant string axioms for \"" << strconst.encode() << '"' << std::endl;);
unsigned int l = strconst.length();
expr_ref len(m_autil.mk_numeral(rational(l), true), m);
@ -1071,8 +1071,8 @@ namespace smt {
void theory_str::instantiate_str_eq_length_axiom(enode * lhs, enode * rhs) {
ast_manager & m = get_manager();
app * a_lhs = lhs->get_owner();
app * a_rhs = rhs->get_owner();
app * a_lhs = lhs->get_expr();
app * a_rhs = rhs->get_expr();
// build premise: (lhs == rhs)
expr_ref premise(ctx.mk_eq_atom(a_lhs, a_rhs), m);
@ -1092,7 +1092,7 @@ namespace smt {
void theory_str::instantiate_axiom_CharAt(enode * e) {
ast_manager & m = get_manager();
expr* arg0, *arg1;
app * expr = e->get_owner();
app * expr = e->get_expr();
if (axiomatized_terms.contains(expr)) {
TRACE("str", tout << "already set up CharAt axiom for " << mk_pp(expr, m) << std::endl;);
return;
@ -1127,7 +1127,7 @@ namespace smt {
void theory_str::instantiate_axiom_prefixof(enode * e) {
ast_manager & m = get_manager();
app * expr = e->get_owner();
app * expr = e->get_expr();
if (axiomatized_terms.contains(expr)) {
TRACE("str", tout << "already set up prefixof axiom for " << mk_pp(expr, m) << std::endl;);
return;
@ -1163,7 +1163,7 @@ namespace smt {
void theory_str::instantiate_axiom_suffixof(enode * e) {
ast_manager & m = get_manager();
app * expr = e->get_owner();
app * expr = e->get_expr();
if (axiomatized_terms.contains(expr)) {
TRACE("str", tout << "already set up suffixof axiom for " << mk_pp(expr, m) << std::endl;);
return;
@ -1199,7 +1199,7 @@ namespace smt {
void theory_str::instantiate_axiom_Contains(enode * e) {
ast_manager & m = get_manager();
app * ex = e->get_owner();
app * ex = e->get_expr();
if (axiomatized_terms.contains(ex)) {
TRACE("str", tout << "already set up Contains axiom for " << mk_pp(ex, m) << std::endl;);
return;
@ -1249,7 +1249,7 @@ namespace smt {
th_rewriter & rw = ctx.get_rewriter();
ast_manager & m = get_manager();
app * ex = e->get_owner();
app * ex = e->get_expr();
if (axiomatized_terms.contains(ex)) {
TRACE("str", tout << "already set up str.indexof axiom for " << mk_pp(ex, m) << std::endl;);
return;
@ -1350,7 +1350,7 @@ namespace smt {
th_rewriter & rw = ctx.get_rewriter();
ast_manager & m = get_manager();
app * e = _e->get_owner();
app * e = _e->get_expr();
if (axiomatized_terms.contains(e)) {
TRACE("str", tout << "already set up extended str.indexof axiom for " << mk_pp(e, m) << std::endl;);
return;
@ -1494,7 +1494,7 @@ namespace smt {
void theory_str::instantiate_axiom_LastIndexof(enode * e) {
ast_manager & m = get_manager();
app * expr = e->get_owner();
app * expr = e->get_expr();
if (axiomatized_terms.contains(expr)) {
TRACE("str", tout << "already set up LastIndexof axiom for " << mk_pp(expr, m) << std::endl;);
return;
@ -1565,7 +1565,7 @@ namespace smt {
expr* substrPos = nullptr;
expr* substrLen = nullptr;
app * expr = e->get_owner();
app * expr = e->get_expr();
if (axiomatized_terms.contains(expr)) {
TRACE("str", tout << "already set up Substr axiom for " << mk_pp(expr, m) << std::endl;);
return;
@ -1667,7 +1667,7 @@ namespace smt {
void theory_str::instantiate_axiom_Replace(enode * e) {
ast_manager & m = get_manager();
app * ex = e->get_owner();
app * ex = e->get_expr();
if (axiomatized_terms.contains(ex)) {
TRACE("str", tout << "already set up Replace axiom for " << mk_pp(ex, m) << std::endl;);
return;
@ -1724,7 +1724,7 @@ namespace smt {
void theory_str::instantiate_axiom_str_to_int(enode * e) {
ast_manager & m = get_manager();
app * ex = e->get_owner();
app * ex = e->get_expr();
if (axiomatized_terms.contains(ex)) {
TRACE("str", tout << "already set up str.to-int axiom for " << mk_pp(ex, m) << std::endl;);
return;
@ -1774,7 +1774,7 @@ namespace smt {
void theory_str::instantiate_axiom_int_to_str(enode * e) {
ast_manager & m = get_manager();
app * ex = e->get_owner();
app * ex = e->get_expr();
if (axiomatized_terms.contains(ex)) {
TRACE("str", tout << "already set up str.from-int axiom for " << mk_pp(ex, m) << std::endl;);
return;
@ -1809,7 +1809,7 @@ namespace smt {
void theory_str::instantiate_axiom_is_digit(enode * e) {
ast_manager & m = get_manager();
app * ex = e->get_owner();
app * ex = e->get_expr();
if (axiomatized_terms.contains(ex)) {
TRACE("str", tout << "already set up str.is_digit axiom for " << mk_pp(ex, m) << std::endl;);
return;
@ -1837,7 +1837,7 @@ namespace smt {
void theory_str::instantiate_axiom_str_from_code(enode * e) {
ast_manager & m = get_manager();
app * ex = e->get_owner();
app * ex = e->get_expr();
if (axiomatized_terms.contains(ex)) {
TRACE("str", tout << "already set up str.from_code axiom for " << mk_pp(ex, m) << std::endl;);
return;
@ -1873,7 +1873,7 @@ namespace smt {
void theory_str::instantiate_axiom_str_to_code(enode * e) {
ast_manager & m = get_manager();
app * ex = e->get_owner();
app * ex = e->get_expr();
if (axiomatized_terms.contains(ex)) {
TRACE("str", tout << "already set up str.to_code axiom for " << mk_pp(ex, m) << std::endl;);
return;
@ -1910,7 +1910,7 @@ namespace smt {
void theory_str::instantiate_axiom_RegexIn(enode * e) {
ast_manager & m = get_manager();
app * ex = e->get_owner();
app * ex = e->get_expr();
if (axiomatized_terms.contains(ex)) {
TRACE("str", tout << "already set up RegexIn axiom for " << mk_pp(ex, m) << std::endl;);
return;
@ -1931,7 +1931,7 @@ namespace smt {
void theory_str::attach_new_th_var(enode * n) {
theory_var v = mk_var(n);
ctx.attach_th_var(n, this, v);
TRACE("str", tout << "new theory var: " << mk_ismt2_pp(n->get_owner(), get_manager()) << " := v#" << v << std::endl;);
TRACE("str", tout << "new theory var: " << mk_ismt2_pp(n->get_expr(), get_manager()) << " := v#" << v << std::endl;);
}
void theory_str::reset_eh() {
@ -2006,7 +2006,7 @@ namespace smt {
// support for user_smt_theory-style EQC handling
app * theory_str::get_ast(theory_var v) {
return get_enode(v)->get_owner();
return get_enode(v)->get_expr();
}
theory_var theory_str::get_var(expr * n) const {
@ -2150,7 +2150,7 @@ namespace smt {
for (auto &e_parent : current_parents) {
SASSERT(e_parent != nullptr);
app * a_parent = e_parent->get_owner();
app * a_parent = e_parent->get_expr();
TRACE("str", tout << "considering parent " << mk_ismt2_pp(a_parent, m) << std::endl;);
if (u.str.is_concat(a_parent)) {
@ -2160,7 +2160,7 @@ namespace smt {
rational parentLen;
bool parentLen_exists = get_len_value(a_parent, parentLen);
if (arg0 == n_eq_enode->get_owner()) {
if (arg0 == n_eq_enode->get_expr()) {
rational arg0Len, arg1Len;
bool arg0Len_exists = get_len_value(eq_str, arg0Len);
bool arg1Len_exists = get_len_value(arg1, arg1Len);
@ -2229,9 +2229,9 @@ namespace smt {
assert_implication(implyL, implyR);
}
}
} // if (arg0 == n_eq_enode->get_owner())
} // if (arg0 == n_eq_enode->get_expr())
if (arg1 == n_eq_enode->get_owner()) {
if (arg1 == n_eq_enode->get_expr()) {
rational arg0Len, arg1Len;
bool arg0Len_exists = get_len_value(arg0, arg0Len);
bool arg1Len_exists = get_len_value(eq_str, arg1Len);
@ -2355,7 +2355,7 @@ namespace smt {
if (arg1 == n_eqNode) {
expr_ref_vector concat_parents(m);
for (auto& e_concat_parent : e_parent->get_parents()) {
concat_parents.push_back(e_concat_parent->get_owner());
concat_parents.push_back(e_concat_parent->get_expr());
}
for (auto& _concat_parent : concat_parents) {
app* concat_parent = to_app(_concat_parent);
@ -2383,7 +2383,7 @@ namespace smt {
if (arg0 == n_eqNode) {
expr_ref_vector concat_parents(m);
for (auto& e_concat_parent : e_parent->get_parents()) {
concat_parents.push_back(e_concat_parent->get_owner());
concat_parents.push_back(e_concat_parent->get_expr());
}
for (auto& _concat_parent : concat_parents) {
app* concat_parent = to_app(_concat_parent);
@ -4607,8 +4607,8 @@ namespace smt {
// if an integer constant exists in the eqc, it should be the root
enode * en_e = ctx.get_enode(e);
enode * root_e = en_e->get_root();
if (m_autil.is_numeral(root_e->get_owner(), val) && val.is_int()) {
TRACE("str", tout << mk_pp(e, get_manager()) << " ~= " << mk_pp(root_e->get_owner(), get_manager()) << std::endl;);
if (m_autil.is_numeral(root_e->get_expr(), val) && val.is_int()) {
TRACE("str", tout << mk_pp(e, get_manager()) << " ~= " << mk_pp(root_e->get_expr(), get_manager()) << std::endl;);
return true;
} else {
TRACE("str", tout << "root of eqc of " << mk_pp(e, get_manager()) << " is not a numeral" << std::endl;);
@ -4691,7 +4691,7 @@ namespace smt {
enode * nNode = ctx.get_enode(len);
enode * eqcNode = nNode;
do {
app * ast = eqcNode->get_owner();
app * ast = eqcNode->get_expr();
tout << mk_pp(ast, get_manager()) << std::endl;
eqcNode = eqcNode->get_next();
} while (eqcNode != nNode);
@ -7052,8 +7052,8 @@ namespace smt {
void theory_str::new_eq_eh(theory_var x, theory_var y) {
//TRACE("str", tout << "new eq: v#" << x << " = v#" << y << std::endl;);
TRACE("str", tout << "new eq: " << mk_ismt2_pp(get_enode(x)->get_owner(), get_manager()) << " = " <<
mk_ismt2_pp(get_enode(y)->get_owner(), get_manager()) << std::endl;);
TRACE("str", tout << "new eq: " << mk_ismt2_pp(get_enode(x)->get_expr(), get_manager()) << " = " <<
mk_ismt2_pp(get_enode(y)->get_expr(), get_manager()) << std::endl;);
candidate_model.reset();
/*
@ -7061,7 +7061,7 @@ namespace smt {
return;
}
*/
handle_equality(get_enode(x)->get_owner(), get_enode(y)->get_owner());
handle_equality(get_enode(x)->get_expr(), get_enode(y)->get_expr());
// replicate Z3str2 behaviour: merge eqc **AFTER** handle_equality
m_find.merge(x, y);
@ -7069,8 +7069,8 @@ namespace smt {
void theory_str::new_diseq_eh(theory_var x, theory_var y) {
//TRACE("str", tout << "new diseq: v#" << x << " != v#" << y << std::endl;);
TRACE("str", tout << "new diseq: " << mk_ismt2_pp(get_enode(x)->get_owner(), get_manager()) << " != " <<
mk_ismt2_pp(get_enode(y)->get_owner(), get_manager()) << std::endl;);
TRACE("str", tout << "new diseq: " << mk_ismt2_pp(get_enode(x)->get_expr(), get_manager()) << " != " <<
mk_ismt2_pp(get_enode(y)->get_expr(), get_manager()) << std::endl;);
candidate_model.reset();
}
@ -7294,7 +7294,7 @@ namespace smt {
ptr_vector<enode> new_m_basicstr;
for (ptr_vector<enode>::iterator it = m_basicstr_axiom_todo.begin(); it != m_basicstr_axiom_todo.end(); ++it) {
enode * e = *it;
TRACE("str", tout << "consider deleting " << mk_pp(e->get_owner(), get_manager())
TRACE("str", tout << "consider deleting " << mk_pp(e->get_expr(), get_manager())
<< ", enode scope level is " << e->get_iscope_lvl()
<< std::endl;);
if (e->get_iscope_lvl() <= (unsigned)sLevel) {
@ -7587,7 +7587,7 @@ namespace smt {
enode * e_curr = ctx.get_enode(unroll);
enode * e_curr_end = e_curr;
do {
app * curr = e_curr->get_owner();
app * curr = e_curr->get_expr();
if (u.str.is_concat(curr)) {
tout << " >>> " << mk_pp(curr, mgr) << std::endl;
}
@ -8531,7 +8531,7 @@ namespace smt {
for (std::set<enode*>::iterator it = eqc_roots.begin(); it != eqc_roots.end(); ++it) {
enode * e = *it;
app * a = e->get_owner();
app * a = e->get_expr();
if (!(a->get_sort() == u.str.mk_string_sort())) {
TRACE("str", tout << "EQC root " << mk_pp(a, m) << " not a string term; skipping" << std::endl;);
} else {
@ -8540,9 +8540,9 @@ namespace smt {
enode * e_it = e;
enode * e_root = e_it;
do {
bool status = check_concat_len_in_eqc(e_it->get_owner());
bool status = check_concat_len_in_eqc(e_it->get_expr());
if (!status) {
TRACE("str", tout << "concat-len check asserted an axiom on " << mk_pp(e_it->get_owner(), m) << std::endl;);
TRACE("str", tout << "concat-len check asserted an axiom on " << mk_pp(e_it->get_expr(), m) << std::endl;);
found_inconsistency = true;
}
e_it = e_it->get_next();
@ -8552,8 +8552,8 @@ namespace smt {
enode * e1 = e;
enode * e2 = e1->get_next();
if (e1 != e2) {
TRACE("str", tout << "deferred new_eq_check() over EQC of " << mk_pp(e1->get_owner(), m) << " and " << mk_pp(e2->get_owner(), m) << std::endl;);
bool result = new_eq_check(e1->get_owner(), e2->get_owner());
TRACE("str", tout << "deferred new_eq_check() over EQC of " << mk_pp(e1->get_expr(), m) << " and " << mk_pp(e2->get_expr(), m) << std::endl;);
bool result = new_eq_check(e1->get_expr(), e2->get_expr());
if (!result) {
TRACE("str", tout << "new_eq_check found inconsistencies" << std::endl;);
found_inconsistency = true;
@ -8813,7 +8813,7 @@ namespace smt {
concatEqUnrollsMap[curr].insert(unrollGroup_map[unroll].begin(), unrollGroup_map[unroll].end());
}
enode * e_curr = ctx.get_enode(curr);
curr = e_curr->get_next()->get_owner();
curr = e_curr->get_next()->get_expr();
// curr = get_eqc_next(curr);
} while (curr != unroll);
}
@ -9025,11 +9025,11 @@ namespace smt {
}
model_value_proc * theory_str::mk_value(enode * n, model_generator & mg) {
TRACE("str", tout << "mk_value for: " << mk_ismt2_pp(n->get_owner(), get_manager()) <<
" (sort " << mk_ismt2_pp(n->get_owner()->get_sort(), get_manager()) << ")" << std::endl;);
TRACE("str", tout << "mk_value for: " << mk_ismt2_pp(n->get_expr(), get_manager()) <<
" (sort " << mk_ismt2_pp(n->get_expr()->get_sort(), get_manager()) << ")" << std::endl;);
ast_manager & m = get_manager();
app_ref owner(m);
owner = n->get_owner();
owner = n->get_expr();
// If the owner is not internalized, it doesn't have an enode associated.
SASSERT(ctx.e_internalized(owner));

2
src/smt/theory_utvpi.h
View file

@ -324,7 +324,7 @@ namespace smt {
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_owner()); }
bool is_int(theory_var v) const { return a.is_int(get_enode(v)->get_expr()); }
th_var get_zero(sort* s) { return a.is_int(s) ? m_izero : m_rzero; }

22
src/smt/theory_utvpi_def.h
View file

@ -98,7 +98,7 @@ namespace smt {
template<typename Ext>
theory_var theory_utvpi<Ext>::mk_var(enode* n) {
th_var v = theory::mk_var(n);
TRACE("utvpi", tout << v << " " << mk_pp(n->get_owner(), m) << "\n";);
TRACE("utvpi", tout << v << " " << mk_pp(n->get_expr(), m) << "\n";);
m_graph.init_var(to_var(v));
m_graph.init_var(neg(to_var(v)));
ctx.attach_th_var(n, this, v);
@ -170,8 +170,8 @@ namespace smt {
//
app_ref eq(m), s2(m), t2(m);
app* s1 = get_enode(s)->get_owner();
app* t1 = get_enode(t)->get_owner();
app* s1 = get_enode(s)->get_expr();
app* t1 = get_enode(t)->get_expr();
s2 = a.mk_sub(t1, s1);
t2 = a.mk_numeral(k, s2->get_sort());
eq = m.mk_eq(s2.get(), t2.get());
@ -438,7 +438,7 @@ namespace smt {
unsigned sz = get_num_vars();
for (unsigned i = 0; i < sz; ++i) {
enode* e = get_enode(i);
if (!a.is_int(e->get_owner())) {
if (!a.is_int(e->get_expr())) {
continue;
}
th_var v1 = to_var(i);
@ -460,7 +460,7 @@ namespace smt {
m_nc_functor.reset();
VERIFY(m_graph.find_shortest_zero_edge_path(v1, v2, UINT_MAX, m_nc_functor));
VERIFY(m_graph.find_shortest_zero_edge_path(v2, v1, UINT_MAX, m_nc_functor));
IF_VERBOSE(1, verbose_stream() << "parity conflict " << mk_pp(e->get_owner(), m) << "\n";);
IF_VERBOSE(1, verbose_stream() << "parity conflict " << mk_pp(e->get_expr(), m) << "\n";);
set_conflict();
return false;
@ -593,7 +593,7 @@ namespace smt {
expr* x, *y;
rational r;
for (;;) {
app* n = e->get_owner();
app* n = e->get_expr();
if (a.is_add(n, x, y)) {
if (a.is_numeral(x, r)) {
e = ctx.get_enode(y);
@ -736,7 +736,7 @@ namespace smt {
unsigned sz = get_num_vars();
for (unsigned i = 0; i < sz; ++i) {
enode* e = get_enode(i);
if (a.is_int(e->get_owner()) && !is_parity_ok(i)) {
if (a.is_int(e->get_expr()) && !is_parity_ok(i)) {
todo.push_back(i);
}
}
@ -781,7 +781,7 @@ namespace smt {
DEBUG_CODE(
for (unsigned i = 0; i < sz; ++i) {
enode* e = get_enode(i);
if (a.is_int(e->get_owner()) && !is_parity_ok(i)) {
if (a.is_int(e->get_expr()) && !is_parity_ok(i)) {
IF_VERBOSE(0, verbose_stream() << "disparities not fixed\n";);
UNREACHABLE();
}
@ -911,7 +911,7 @@ namespace smt {
num = num/rational(2);
SASSERT(!is_int || num.is_int());
TRACE("utvpi",
expr* n = get_enode(v)->get_owner();
expr* n = get_enode(v)->get_expr();
tout << mk_pp(n, m) << " |-> (" << val1 << " - " << val2 << ")/2 = " << num << "\n";);
return num;
@ -920,9 +920,9 @@ namespace smt {
template<typename Ext>
model_value_proc * theory_utvpi<Ext>::mk_value(enode * n, model_generator & mg) {
theory_var v = n->get_th_var(get_id());
bool is_int = a.is_int(n->get_owner());
bool is_int = a.is_int(n->get_expr());
rational num = mk_value(v, is_int);
TRACE("utvpi", tout << mk_pp(n->get_owner(), m) << " |-> " << num << "\n";);
TRACE("utvpi", tout << mk_pp(n->get_expr(), m) << " |-> " << num << "\n";);
return alloc(expr_wrapper_proc, m_factory->mk_num_value(num, is_int));
}

2
src/smt/theory_wmaxsat.cpp
View file

@ -248,7 +248,7 @@ namespace smt {
TRACE("opt",
tout << "costs: ";
for (unsigned i = 0; i < m_costs.size(); ++i) {
tout << mk_pp(get_enode(m_costs[i])->get_owner(), get_manager()) << " ";
tout << pp(get_enode(m_costs[i]), get_manager()) << " ";
}
tout << "\n";
//ctx.display(tout);