add projection with witnesses

expose model based projection with witness creation

src/api/api_qe.cpp

@@ -26,6 +26,7 @@ Notes:
 #include "api/api_ast_map.h"
 #include "api/api_ast_vector.h"
 #include "qe/lite/qe_lite_tactic.h"
+#include "qe/qe_mbp.h"
 #include "muz/spacer/spacer_util.h"
 
 extern "C"
@@ -104,6 +105,46 @@ extern "C"
         Z3_CATCH_RETURN(nullptr);
     }
 
+    Z3_ast Z3_API Z3_qe_model_project_with_witness (Z3_context c,
+                                              Z3_model mdl,
+                                              unsigned num_bounds,
+                                              Z3_app const bound[],
+                                              Z3_ast body,
+                                              Z3_ast_map map)
+    {
+        Z3_TRY;
+        LOG_Z3_qe_model_project_with_witness (c, mdl, num_bounds, bound, body, map);
+        RESET_ERROR_CODE();
+
+        ast_manager& m = mk_c(c)->m();
+        app_ref_vector vars(m);
+        if (!to_apps(num_bounds, bound, vars)) {
+            RETURN_Z3(nullptr);
+        }
+
+        expr_ref_vector fmls(m);
+        fmls.push_back(to_expr(body));
+        model_ref model (to_model_ref (mdl));
+        vector<mbp::def> defs;
+        qe::mbproj proj(m);
+
+        proj(true, vars, *model, fmls, &defs);
+        expr_ref result (m);
+        result = m.mk_and(fmls);
+        mk_c(c)->save_ast_trail(result);
+
+        obj_map<ast, ast*> &map_z3 = to_ast_map_ref(map);
+
+        for (auto& [v, t] : defs) {
+            m.inc_ref(v);
+            m.inc_ref(t);
+            map_z3.insert(v, t);            
+        }
+
+        return of_expr (result);
+        Z3_CATCH_RETURN(nullptr);
+    }
+
     Z3_ast Z3_API Z3_model_extrapolate (Z3_context c,
                                         Z3_model m,
                                         Z3_ast fml)

src/api/python/z3/z3.py

@@ -6732,6 +6732,30 @@ class ModelRef(Z3PPObject):
         model = Z3_model_translate(self.ctx.ref(), self.model, target.ref())
         return ModelRef(model, target)
 
+    def project(self, vars, fml):
+        """Perform model-based projection on fml with respect to vars.
+        Assume that the model satisfies fml. Then compute a projection fml_p, such
+        that vars do not occur free in fml_p, fml_p is true in the model and
+        fml_p => exists vars . fml
+        """
+        ctx = self.ctx.ref()
+        _vars = (Ast * len(vars))()
+        for i in range(len(vars)):
+            _vars[i] = vars[i].as_ast()
+        return _to_expr_ref(Z3_qe_model_project(ctx, self.model, len(vars), _vars, fml.ast), self.ctx)
+
+    def project_with_witness(self, vars, fml):
+        """Perform model-based projection, but also include realizer terms for the projected variables"""
+        ctx = self.ctx.ref()
+        _vars = (Ast * len(vars))()
+        for i in range(len(vars)):
+            _vars[i] = vars[i].as_ast()
+        defs = AstMap()
+        result = Z3_qe_model_project_with_witness(ctx, self.model, len(vars), _vars, fml.ast, defs.map)
+        result = _to_expr_ref(result, self.ctx)
+        return result, defs
+
+
     def __copy__(self):
         return self.translate(self.ctx)
 
@@ -6739,9 +6763,12 @@ class ModelRef(Z3PPObject):
         return self.translate(self.ctx)
 
 
-def Model(ctx=None):
+def Model(ctx=None, eval = {}):
     ctx = _get_ctx(ctx)
-    return ModelRef(Z3_mk_model(ctx.ref()), ctx)
+    mdl = ModelRef(Z3_mk_model(ctx.ref()), ctx)
+    for k, v in eval.items():
+        mdl.update_value(k, v)
+    return mdl
 
 
 def is_as_array(n):

src/api/z3_spacer.h

@@ -112,6 +112,22 @@ extern "C" {
        Z3_ast body,
        Z3_ast_map map);
 
+    /**
+       \brief Project with witness extraction.
+
+       The returned map contains a binding of variables to terms that such that when the binding
+       is used for the formula, it remains true within the model.
+
+       def_API('Z3_qe_model_project_with_witness', AST, (_in(CONTEXT), _in(MODEL), _in(UINT), _in_array(2, APP), _in(AST), _in(AST_MAP)))
+    */
+    Z3_ast Z3_API Z3_qe_model_project_with_witness
+      (Z3_context c,
+       Z3_model m,
+       unsigned num_bounds,
+       Z3_app const bound[],
+       Z3_ast body,
+       Z3_ast_map map);
+
     /**
        \brief Extrapolates a model of a formula