void context::display(std::ostream & out) const {
get_pp_visited().reset();
out << "Logical context:\n";
out << "scope-lvl: " << m_scope_lvl << "\n";
out << "base-lvl: " << m_base_lvl << "\n";
out << "search-lvl: " << m_search_lvl << "\n";
out << "inconsistent(): " << inconsistent() << "\n";
out << "m_asserted_formulas.inconsistent(): " << m_asserted_formulas.inconsistent() << "\n";
display_bool_var_defs(out);
display_enode_defs(out);
display_asserted_formulas(out);
if (!m_aux_clauses.empty()) {
out << "auxiliary clauses:\n";
display_clauses(out, m_aux_clauses);
}
if (!m_lemmas.empty()) {
out << "lemmas:\n";
display_clauses(out, m_lemmas);
}
display_binary_clauses(out);
display_assignment(out);
display_eqc(out);
m_cg_table.display_compact(out);
m_case_split_queue->display(out);
display_expr_bool_var_map(out);
display_app_enode_map(out);
display_relevant_exprs(out);
display_theories(out);
display_decl2enodes(out);
display_hot_bool_vars(out);
}
void asserted_formulas::push_assertion(expr * e, proof * pr, vector<justified_expr>& result) {
if (inconsistent()) {
return;
}
expr* e1 = nullptr;
if (m.is_false(e)) {
result.push_back(justified_expr(m, e, pr));
m_inconsistent = true;
}
else if (m.is_true(e)) {
// skip
}
else if (m.is_and(e)) {
for (unsigned i = 0; i < to_app(e)->get_num_args(); ++i) {
expr* arg = to_app(e)->get_arg(i);
proof_ref _pr(m.proofs_enabled() ? m.mk_and_elim(pr, i) : nullptr, m);
push_assertion(arg, _pr, result);
}
}
else if (m.is_not(e, e1) && m.is_or(e1)) {
for (unsigned i = 0; i < to_app(e1)->get_num_args(); ++i) {
expr* arg = to_app(e1)->get_arg(i);
proof_ref _pr(m.proofs_enabled() ? m.mk_not_or_elim(pr, i) : nullptr, m);
expr_ref narg(mk_not(m, arg), m);
push_assertion(narg, _pr, result);
}
}
else {
result.push_back(justified_expr(m, e, pr));
}
}
void goal::elim_redundancies() {
if (inconsistent())
return;
expr_ref_fast_mark1 neg_lits(m());
expr_ref_fast_mark2 pos_lits(m());
unsigned sz = size();
unsigned j = 0;
for (unsigned i = 0; i < sz; i++) {
expr * f = form(i);
if (m().is_true(f))
continue;
if (m().is_not(f)) {
expr * atom = to_app(f)->get_arg(0);
if (neg_lits.is_marked(atom))
continue;
if (pos_lits.is_marked(atom)) {
proof * p = 0;
if (proofs_enabled()) {
proof * prs[2] = { pr(get_idx(atom)), pr(i) };
p = m().mk_unit_resolution(2, prs);
}
expr_dependency_ref d(m());
if (unsat_core_enabled())
d = m().mk_join(dep(get_idx(atom)), dep(i));
push_back(m().mk_false(), p, d);
return;
}
neg_lits.mark(atom);
}
else {
if (pos_lits.is_marked(f))
continue;
if (neg_lits.is_marked(f)) {
proof * p = 0;
if (proofs_enabled()) {
proof * prs[2] = { pr(get_not_idx(f)), pr(i) };
p = m().mk_unit_resolution(2, prs);
}
expr_dependency_ref d(m());
if (unsat_core_enabled())
d = m().mk_join(dep(get_not_idx(f)), dep(i));
push_back(m().mk_false(), p, d);
return;
}
pos_lits.mark(f);
}
if (i == j) {
j++;
continue;
}
m().set(m_forms, j, f);
if (proofs_enabled())
m().set(m_proofs, j, pr(i));
if (unsat_core_enabled())
m().set(m_dependencies, j, dep(i));
j++;
}
shrink(j);
}
void bound_propagator::push() {
m_scopes.push_back(scope());
scope & s = m_scopes.back();
s.m_trail_limit = m_trail.size();
s.m_qhead_old = m_qhead;
s.m_reinit_stack_limit = m_reinit_stack.size();
s.m_timestamp_old = m_timestamp;
s.m_in_conflict = inconsistent();
}
void asserted_formulas::assert_expr(expr * e, proof * _in_pr) {
proof_ref in_pr(_in_pr, m), pr(_in_pr, m);
expr_ref r(e, m);
if (inconsistent())
return;
if (m_smt_params.m_preprocess) {
TRACE("assert_expr_bug", tout << r << "\n";);
void normalize_eq(unsigned eq_idx) {
if (inconsistent())
return;
equation & eq = *(m_equations[eq_idx]);
TRACE("euclidean_solver", tout << "normalizing:\n"; display(tout, eq); tout << "\n";);
bool goal::is_decided_unsat() const {
return inconsistent() && unsat_preserved();
}
void assertion_set::elim_redundancies() {
if (inconsistent())
return;
expr_ref_fast_mark1 neg_lits(m());
expr_ref_fast_mark2 pos_lits(m());
unsigned sz = size();
unsigned j = 0;
for (unsigned i = 0; i < sz; i++) {
expr * f = form(i);
if (m().is_true(f))
continue;
if (m().is_not(f)) {
expr * atom = to_app(f)->get_arg(0);
if (neg_lits.is_marked(atom))
continue;
if (pos_lits.is_marked(atom)) {
proof * p = 0;
if (m().proofs_enabled()) {
proof * pr1 = 0;
proof * pr2 = pr(i);
for (unsigned j = 0; j < i; j++) {
if (form(j) == atom) {
pr1 = pr(j);
break;
}
}
SASSERT(pr1);
proof * prs[2] = { pr1, pr2 };
p = m().mk_unit_resolution(2, prs);
}
push_back(m().mk_false(), p);
return;
}
neg_lits.mark(atom);
}
else {
if (pos_lits.is_marked(f))
continue;
if (neg_lits.is_marked(f)) {
proof * p = 0;
if (m().proofs_enabled()) {
proof * pr1 = 0;
proof * pr2 = pr(i);
for (unsigned j = 0; j < i; j++) {
expr * curr = form(j);
expr * atom;
if (m().is_not(curr, atom) && atom == f) {
pr1 = pr(j);
break;
}
}
SASSERT(pr1);
proof * prs[2] = { pr1, pr2 };
p = m().mk_unit_resolution(2, prs);
}
push_back(m().mk_false(), p);
return;
}
pos_lits.mark(f);
}
if (i == j) {
j++;
continue;
}
m().set(m_forms, j, f);
if (m().proofs_enabled())
m().set(m_proofs, j, pr(i));
j++;
}
for (; j < sz; j++) {
m().pop_back(m_forms);
if (m().proofs_enabled())
m().pop_back(m_proofs);
}
}
