mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-07-19 19:02:02 +00:00
Code Activity

Treat eval'd literals as propagations (not as decisions)

Browse source
This commit is contained in:
Jakob Rath 2022-01-21 15:55:05 +01:00
parent 8765dc16a5
commit c4c9c84aeb
7 changed files with 92 additions and 45 deletions
Download patch file Download diff file Expand all files Collapse all files

41
src/math/polysat/boolean.h
View file

@ -19,20 +19,28 @@ namespace polysat {
class clause;
class bool_var_manager {
enum class kind_t {
unassigned,
propagation,
decision,
};
svector<sat::bool_var> m_unused; // previously deleted variables that can be reused by new_var();
svector<lbool> m_value; // current value (indexed by literal)
unsigned_vector m_level; // level of assignment (indexed by variable)
unsigned_vector m_deps; // dependencies of external asserts
unsigned_vector m_activity; //
ptr_vector<clause> m_reason; // propagation reason, NULL for decisions and external asserts (indexed by variable)
// For enumerative backtracking we store the lemma we're handling with a certain decision
ptr_vector<clause> m_lemma;
unsigned_vector m_activity; //
svector<kind_t> m_kind; // decision or propagation?
// Clause associated with the assignment (indexed by variable):
// - for propagations: the reason (or NULL for eval'd literals)
// - for decisions: the lemma (or NULL for externally asserted literals)
ptr_vector<clause> m_clause;
var_queue m_free_vars; // free Boolean variables
vector<ptr_vector<clause>> m_watch; // watch list for literals into clauses
void assign(sat::literal lit, unsigned lvl, clause* reason, clause* lemma, unsigned dep = null_dependency);
void assign(kind_t k, sat::literal lit, unsigned lvl, clause* reason, unsigned dep = null_dependency);
public:
@ -46,19 +54,21 @@ namespace polysat {
bool is_assigned(sat::bool_var var) const { return value(var) != l_undef; }
bool is_assigned(sat::literal lit) const { return value(lit) != l_undef; }
bool is_decision(sat::bool_var var) const { return is_assigned(var) && !reason(var); }
bool is_decision(sat::bool_var var) const { return is_assigned(var) && m_kind[var] == kind_t::decision; }
bool is_decision(sat::literal lit) const { return is_decision(lit.var()); }
bool is_propagation(sat::bool_var var) const { return is_assigned(var) && reason(var); }
bool is_propagation(sat::bool_var var) const { return is_assigned(var) && m_kind[var] == kind_t::propagation; }
bool is_propagation(sat::literal lit) const { return is_propagation(lit.var()); }
lbool value(sat::bool_var var) const { return value(sat::literal(var)); }
lbool value(sat::literal lit) const { return m_value[lit.index()]; }
bool is_true(sat::literal lit) const { return value(lit) == l_true; }
bool is_false(sat::literal lit) const { return value(lit) == l_false; }
unsigned level(sat::bool_var var) const { SASSERT(is_assigned(var)); return m_level[var]; }
unsigned level(sat::literal lit) const { return level(lit.var()); }
clause* reason(sat::bool_var var) const { SASSERT(is_assigned(var)); return m_reason[var]; }
clause* reason(sat::bool_var var) const { SASSERT(is_assigned(var)); return is_propagation(var) ? m_clause[var] : nullptr; }
clause* reason(sat::literal lit) const { return reason(lit.var()); }
unsigned dep(sat::literal lit) const { return lit == sat::null_literal ? null_dependency : m_deps[lit.var()]; }
clause* lemma(sat::bool_var var) const { SASSERT(is_decision(var)); return m_lemma[var]; }
clause* lemma(sat::bool_var var) const { SASSERT(is_decision(var)); return m_clause[var]; }
ptr_vector<clause>& watch(sat::literal lit) { return m_watch[lit.index()]; }
unsigned_vector& activity() { return m_activity; }
@ -71,12 +81,21 @@ namespace polysat {
/// Set the given literal to true
void propagate(sat::literal lit, unsigned lvl, clause& reason);
void decide(sat::literal lit, unsigned lvl, clause* lemma);
void decide(sat::literal lit, unsigned lvl, clause& lemma);
void eval(sat::literal lit, unsigned lvl);
void asserted(sat::literal lit, unsigned lvl, unsigned dep);
void unassign(sat::literal lit);
std::ostream& display(std::ostream& out) const;
friend std::ostream& operator<<(std::ostream& out, kind_t const& k) {
switch (k) {
case kind_t::unassigned: return out << "unassigned"; break;
case kind_t::propagation: return out << "propagation"; break;
case kind_t::decision: return out << "decision"; break;
default: UNREACHABLE();
}
}
};
inline std::ostream& operator<<(std::ostream& out, bool_var_manager const& m) { return m.display(out); }