merge

Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com>

src/solver/mus.cpp

@@ -217,13 +217,12 @@ struct mus::imp {
         }
 
         expr_set mss_set;
-        for (unsigned i = 0; i < mss.size(); ++i) {
-            mss_set.insert(mss[i]);
+        for (expr* e : mss) {
+            mss_set.insert(e);
         }
-        expr_set::iterator it = min_core.begin(), end = min_core.end();
-        for (; it != end; ++it) {
-            if (mss_set.contains(*it) && min_lit != *it) {
-                unknown.push_back(*it);
+        for (expr * e : min_core) {
+            if (mss_set.contains(e) && min_lit != e) {
+                unknown.push_back(e);
             }
         }
         core_literal = min_lit;

src/solver/parallel_tactic.cpp

@@ -672,11 +672,11 @@ public:
         init();
     }
 
-    void operator ()(const goal_ref & g,goal_ref_buffer & result) {
+    void operator ()(const goal_ref & g,goal_ref_buffer & result) override {
         fail_if_proof_generation("parallel-tactic", g);
         ast_manager& m = g->m();        
         solver* s = m_solver->translate(m, m_params);
-        solver_state* st = alloc(solver_state, 0, s, m_params);
+        solver_state* st = alloc(solver_state, nullptr, s, m_params);
         m_queue.add_task(st);
         expr_ref_vector clauses(m);
         ptr_vector<expr> assumptions;
@@ -719,29 +719,29 @@ public:
         return pp.conquer_batch_size();
     }
 
-    void cleanup() {
+    void cleanup() override {
         m_queue.reset();
     }
 
-    tactic* translate(ast_manager& m) {
+    tactic* translate(ast_manager& m) override {
         solver* s = m_solver->translate(m, m_params);
         return alloc(parallel_tactic, s, m_params);
     }
 
-    virtual void updt_params(params_ref const & p) {
+    void updt_params(params_ref const & p) override {
         m_params.copy(p);
         parallel_params pp(p);
         m_conquer_delay = pp.conquer_delay();
     }
 
-    virtual void collect_statistics(statistics & st) const {
+    void collect_statistics(statistics & st) const override {
         st.copy(m_stats);
         st.update("par unsat", m_num_unsat);
         st.update("par models", m_models.size());
         st.update("par progress", m_progress);
     }
 
-    virtual void reset_statistics() {
+    void reset_statistics() override {
         m_stats.reset();
     }
 };

src/solver/solver.cpp

@@ -178,10 +178,19 @@ lbool solver::preferred_sat(expr_ref_vector const& asms, vector<expr_ref_vector>
     return check_sat(0, nullptr);
 }
 
-bool solver::is_literal(ast_manager& m, expr* e) {
-    return is_uninterp_const(e) || (m.is_not(e, e) && is_uninterp_const(e));
+
+static bool is_m_atom(ast_manager& m, expr* f) {
+    if (!is_app(f)) return true;
+    app* _f = to_app(f);
+    family_id bfid = m.get_basic_family_id();
+    if (_f->get_family_id() != bfid) return true;
+    if (_f->get_num_args() > 0 && m.is_bool(_f->get_arg(0))) return false;    
+    return m.is_eq(f) || m.is_distinct(f);
 }
 
+bool solver::is_literal(ast_manager& m, expr* e) {
+    return is_m_atom(m, e) || (m.is_not(e, e) && is_m_atom(m, e));
+}
 
 void solver::assert_expr(expr* f) {
     expr_ref fml(f, get_manager());
@@ -256,3 +265,40 @@ expr_ref_vector solver::get_units(ast_manager& m) {
 
     return result;
 }
+
+
+expr_ref_vector solver::get_non_units(ast_manager& m) {
+    expr_ref_vector result(m), fmls(m);
+    get_assertions(fmls);
+    family_id bfid = m.get_basic_family_id();
+    expr_mark marked;
+    unsigned sz0 = fmls.size();
+    for (unsigned i = 0; i < fmls.size(); ++i) {
+        expr* f = fmls.get(i);
+        if (marked.is_marked(f)) continue;
+        marked.mark(f);
+        if (!is_app(f)) {
+            if (i >= sz0) result.push_back(f);
+            continue;
+        }
+        app* _f = to_app(f);
+        if (_f->get_family_id() == bfid) {
+            // basic objects are true/false/and/or/not/=/distinct 
+            // and proof objects (that are not Boolean).
+            if (i < sz0 && m.is_not(f) && is_m_atom(m, _f->get_arg(0))) {
+                marked.mark(_f->get_arg(0));
+            }
+            else if (_f->get_num_args() > 0 && m.is_bool(_f->get_arg(0))) {
+                fmls.append(_f->get_num_args(), _f->get_args());
+            }
+            else if (i >= sz0 && is_m_atom(m, f)) {
+                result.push_back(f);
+            }
+        }
+        
+        else {
+            if (i >= sz0) result.push_back(f);
+        }
+    }
+    return result;
+}

src/solver/solver.h

@@ -236,6 +236,8 @@ public:
     */
     expr_ref_vector get_units(ast_manager& m);
 
+    expr_ref_vector get_non_units(ast_manager& m);
+
     class scoped_push {
         solver& s;
         bool    m_nopop;

src/solver/solver_na2as.cpp

@@ -31,7 +31,7 @@ solver_na2as::solver_na2as(ast_manager & m):
 solver_na2as::~solver_na2as() {}
 
 void solver_na2as::assert_expr_core2(expr * t, expr * a) {
-    if (a == 0) {
+    if (a == nullptr) {
         assert_expr_core(t);
     }
     else {

src/solver/tactic2solver.cpp

@@ -79,6 +79,7 @@ public:
 
 
     expr_ref_vector cube(expr_ref_vector& vars, unsigned ) override {
+        set_reason_unknown("cubing is not supported on tactics");
         return expr_ref_vector(get_manager());
     }