sat solver setup

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

src/sat/smt/CMakeLists.txt

@@ -0,0 +1,8 @@
+z3_add_component(sat_smt
+  SOURCES
+    atom2bool_var.cpp
+  COMPONENT_DEPENDENCIES
+    sat
+    ast
+)
+

src/sat/smt/atom2bool_var.cpp

@@ -0,0 +1,140 @@
+/*++
+Copyright (c) 2011 Microsoft Corporation
+
+Module Name:
+
+    atom2bool_var.cpp
+
+Abstract:
+
+    The mapping between SAT boolean variables and atoms
+
+Author:
+
+    Leonardo (leonardo) 2011-10-25
+
+Notes:
+
+--*/
+
+#include "util/ref_util.h"
+#include "ast/ast_smt2_pp.h"
+#include "tactic/goal.h"
+#include "sat/smt/atom2bool_var.h"
+
+void atom2bool_var::mk_inv(expr_ref_vector & lit2expr) const {
+    for (auto const& kv : m_mapping) {
+        sat::literal l(static_cast<sat::bool_var>(kv.m_value), false);
+        lit2expr.set(l.index(), kv.m_key);
+        l.neg();
+        lit2expr.set(l.index(), m().mk_not(kv.m_key));
+    }
+}
+
+void atom2bool_var::mk_var_inv(app_ref_vector & var2expr) const {
+    for (auto const& kv : m_mapping) {
+        var2expr.reserve(kv.m_value + 1);
+        var2expr.set(kv.m_value, to_app(kv.m_key));
+    }
+}
+
+sat::bool_var atom2bool_var::to_bool_var(expr * n) const {
+    unsigned idx = m_id2map.get(n->get_id(), UINT_MAX);
+    if (idx == UINT_MAX) {
+        return sat::null_bool_var;
+    }
+    else {
+        return m_mapping[idx].m_value;
+    }
+}
+
+struct collect_boolean_interface_proc {
+    struct visitor {
+        obj_hashtable<expr> & m_r;
+        visitor(obj_hashtable<expr> & r):m_r(r) {}
+        void operator()(var * n)  {}
+        void operator()(app * n)  { if (is_uninterp_const(n)) m_r.insert(n); }       
+        void operator()(quantifier * n) {} 
+    };
+
+    ast_manager &    m;
+    expr_fast_mark2  fvisited;
+    expr_fast_mark1  tvisited;
+    ptr_vector<expr> todo;
+    visitor          proc;
+
+    collect_boolean_interface_proc(ast_manager & _m, obj_hashtable<expr> & r):
+        m(_m),
+        proc(r) {
+    }
+
+    void process(expr * f) {
+        if (fvisited.is_marked(f))
+            return;
+        fvisited.mark(f);
+        todo.push_back(f);
+        while (!todo.empty()) {
+            expr * t = todo.back();
+            todo.pop_back();
+            if (is_uninterp_const(t))
+                continue;
+            if (is_app(t) && to_app(t)->get_family_id() == m.get_basic_family_id() && to_app(t)->get_num_args() > 0) {
+                decl_kind k = to_app(t)->get_decl_kind();
+                if (k == OP_OR || k == OP_NOT || ((k == OP_EQ || k == OP_ITE) && m.is_bool(to_app(t)->get_arg(1)))) {
+                    unsigned num = to_app(t)->get_num_args();
+                    for (unsigned i = 0; i < num; i++) {
+                        expr * arg = to_app(t)->get_arg(i);
+                        if (fvisited.is_marked(arg))
+                            continue;
+                        fvisited.mark(arg);
+                        todo.push_back(arg);
+                    }
+                }
+            }
+            else {
+                quick_for_each_expr(proc, tvisited, t);
+            }
+        }
+    }
+    
+    template<typename T>
+    void operator()(T const & g) {
+        unsigned sz = g.size();
+        ptr_vector<expr> deps, all_deps;
+        for (unsigned i = 0; i < sz; i++) {
+            if (g.dep(i)) {
+                deps.reset();
+                m.linearize(g.dep(i), deps);
+                all_deps.append(deps);
+            }
+        }
+
+        for (unsigned i = 0; i < all_deps.size(); i++) {
+            quick_for_each_expr(proc, tvisited, all_deps[i]);
+        }
+        for (unsigned i = 0; i < sz; i++) {
+            process(g.form(i));
+        }
+
+    }
+    
+    void operator()(unsigned sz, expr * const * fs) {
+        for (unsigned i = 0; i < sz; i++)
+            process(fs[i]);
+    }
+};
+
+template<typename T>
+void collect_boolean_interface_core(T const & s, obj_hashtable<expr> & r) {
+    collect_boolean_interface_proc proc(s.m(), r);
+    proc(s);
+}
+
+void collect_boolean_interface(goal const & g, obj_hashtable<expr> & r) {
+    collect_boolean_interface_core(g, r);
+}
+
+void collect_boolean_interface(ast_manager & m, unsigned num, expr * const * fs, obj_hashtable<expr> & r) {
+    collect_boolean_interface_proc proc(m, r);
+    proc(num, fs);
+}

src/sat/smt/atom2bool_var.h

@@ -0,0 +1,42 @@
+/*++
+Copyright (c) 2011 Microsoft Corporation
+
+Module Name:
+
+    atom2bool_var.h
+
+Abstract:
+
+    The mapping between SAT boolean variables and atoms
+
+Author:
+
+    Leonardo (leonardo) 2011-10-25
+
+Notes:
+
+--*/
+#pragma once
+
+#include "ast/expr2var.h"
+#include "sat/sat_types.h"
+
+/**
+   \brief Mapping from atoms into SAT boolean variables.
+*/
+class atom2bool_var : public expr2var {
+public:
+    atom2bool_var(ast_manager & m):expr2var(m) {}
+    void insert(expr * n, sat::bool_var v) { expr2var::insert(n, v); }
+    sat::bool_var to_bool_var(expr * n) const;
+    void mk_inv(expr_ref_vector & lit2expr) const;
+    void mk_var_inv(app_ref_vector & var2expr) const;
+    // return true if the mapping contains uninterpreted atoms.
+    bool interpreted_atoms() const { return expr2var::interpreted_vars(); }
+};
+
+class goal;
+
+void collect_boolean_interface(goal const & g, obj_hashtable<expr> & r);
+void collect_boolean_interface(ast_manager & m, unsigned num, expr * const * fs, obj_hashtable<expr> & r);
+

src/sat/smt/sat_smt.h

@@ -0,0 +1,62 @@
+/*++
+Copyright (c) 2020 Microsoft Corporation
+
+Module Name:
+
+    sat_smt.h
+
+Abstract:
+
+    Header for SMT theories over SAT solver
+
+Author:
+
+    Nikolaj Bjorner (nbjorner) 2020-08-25
+
+--*/
+#pragma once
+
+
+#pragma once
+#include "sat/sat_solver.h"
+#include "ast/ast.h"
+
+namespace sat {
+    
+    struct frame {
+        expr* m_e;
+        unsigned m_idx;
+        frame(expr* e) : m_e(e), m_idx(0) {}
+    };
+
+    struct scoped_stack {
+        svector<frame>& s;
+        unsigned sz;
+        scoped_stack(svector<frame>& s):s(s), sz(s.size()) {}
+        ~scoped_stack() { s.shrink(sz); }
+    };
+
+    class sat_internalizer {
+    public:
+        virtual bool is_bool_op(expr* e) const = 0;
+        virtual sat::literal internalize(expr* e) = 0;
+        virtual sat::bool_var add_bool_var(expr* e)  = 0;
+        virtual void mk_clause(literal a, literal b) = 0;
+        virtual void mk_clause(literal l1, literal l2, literal l3, bool is_lemma = false) = 0;
+        virtual void cache(app* t, literal l) = 0;
+    };
+    
+    class th_internalizer {
+    public:
+        virtual literal internalize(sat_internalizer& si, expr* e, bool sign, bool root) = 0;
+    };
+
+    class index_base {
+        extension* ex;
+    public:
+        index_base(extension* e): ex(e) {}
+        static extension* to_extension(size_t s) { return from_index(s)->ex; }
+        static index_base* from_index(size_t s) { return reinterpret_cast<index_base*>(s); }
+        size_t to_index() const { return reinterpret_cast<size_t>(this); }
+    };
+}