add_constraint API

src/api/api_datalog.cpp

@@ -619,6 +619,10 @@ extern "C" {
         Z3_CATCH;
     }
 
+    void Z3_API Z3_fixedpoint_add_constraint (Z3_context c, Z3_fixedpoint d, Z3_ast e, unsigned lvl){
+        to_fixedpoint_ref(d)->ctx().add_constraint(to_expr(e), lvl);
+    }
+
 #include "api_datalog_spacer.inc"
 
 };

src/api/z3_fixedpoint.h

@@ -367,7 +367,7 @@ extern "C" {
     void Z3_API Z3_fixedpoint_set_reduce_app_callback(
         Z3_context c, Z3_fixedpoint d, Z3_fixedpoint_reduce_app_callback_fptr cb);
 
-    typedef void (*Z3_fixedpoint_new_lemma_eh)(void *state, Z3_ast *lemma, unsigned level);
+    typedef void (*Z3_fixedpoint_new_lemma_eh)(void *state, Z3_ast lemma, unsigned level);
     typedef void (*Z3_fixedpoint_predecessor_eh)(void *state);
     typedef void (*Z3_fixedpoint_unfold_eh)(void *state);
 
@@ -377,6 +377,8 @@ extern "C" {
                                             Z3_fixedpoint_predecessor_eh predecessor_eh,
                                             Z3_fixedpoint_unfold_eh unfold_eh);
 
+    void Z3_fixedpoint_add_constraint (Z3_context c, Z3_fixedpoint d, Z3_ast e, unsigned lvl);
+
     /*@}*/
     /*@}*/
 

src/muz/base/dl_context.h

@@ -596,6 +596,11 @@ namespace datalog {
             m_engine->add_callback(state, new_lemma_eh, predecessor_eh, unfold_eh);
         }
 
+        void add_constraint (expr *c, unsigned lvl){
+            ensure_engine();
+            m_engine->add_constraint(c, lvl);
+        }
+
     private:
 
         /**

src/muz/base/dl_engine_base.h

@@ -112,6 +112,9 @@ namespace datalog {
                                   const t_unfold_eh unfold_eh) {
             throw default_exception(std::string("add_lemma_exchange_callbacks is not supported for ") + m_name);
         }
+        virtual void add_constraint (expr *c, unsigned lvl){
+            throw default_exception(std::string("add_constraint is not supported for ") + m_name);
+        }
         virtual void updt_params() {}
         virtual void cancel() {}
         virtual void cleanup() {}

src/muz/spacer/spacer_callback.h

@@ -45,15 +45,15 @@ namespace spacer {
                 m_predecessor_eh(predecessor_eh),
                 m_unfold_eh(unfold_eh) {}
 
-        inline bool new_lemma() override { return true; }
+        inline bool new_lemma() override { return m_new_lemma_eh != nullptr; }
 
         void new_lemma_eh(expr *lemma, unsigned level) override;
 
-        inline bool predecessor() override { return true; }
+        inline bool predecessor() override { return m_predecessor_eh != nullptr; }
 
         void predecessor_eh() override;
 
-        inline bool unfold() override { return true; }
+        inline bool unfold() override { return m_unfold_eh != nullptr; }
 
         void unfold_eh() override;
 

src/muz/spacer/spacer_context.cpp

@@ -1229,21 +1229,21 @@ void lemma::mk_expr_core() {
     normalize(m_body, m_body);
 
     if (!m_zks.empty() && has_zk_const(m_body)) {
-        app_ref_vector zks(m);
+            app_ref_vector zks(m);
         zks.append(m_zks);
-        zks.reverse();
-        expr_abstract(m, 0,
-                      zks.size(), (expr* const*)zks.c_ptr(), m_body,
-                      m_body);
-        ptr_buffer<sort> sorts;
-        svector<symbol> names;
-        for (unsigned i=0, sz=zks.size(); i < sz; ++i) {
-            sorts.push_back(get_sort(zks.get(i)));
-            names.push_back(zks.get(i)->get_decl()->get_name());
-        }
-        m_body = m.mk_quantifier(true, zks.size(),
-                                 sorts.c_ptr(),
-                                 names.c_ptr(),
+            zks.reverse();
+            expr_abstract(m, 0,
+                          zks.size(), (expr* const*)zks.c_ptr(), m_body,
+                          m_body);
+            ptr_buffer<sort> sorts;
+            svector<symbol> names;
+            for (unsigned i=0, sz=zks.size(); i < sz; ++i) {
+                sorts.push_back(get_sort(zks.get(i)));
+                names.push_back(zks.get(i)->get_decl()->get_name());
+            }
+            m_body = m.mk_quantifier(true, zks.size(),
+                                     sorts.c_ptr(),
+                                     names.c_ptr(),
                                  m_body, 15, symbol(m_body->get_id()));
     }
     SASSERT(m_body);
@@ -3590,17 +3590,11 @@ expr_ref context::get_constraints (unsigned level)
     return m_pm.mk_and (constraints);
 }
 
-void context::add_constraints (unsigned level, const expr_ref& c)
+void context::add_constraint (unsigned level, const expr_ref& c)
 {
     if (!c.get()) { return; }
     if (m.is_true(c)) { return; }
 
-    expr_ref_vector constraints (m);
-    constraints.push_back (c);
-    flatten_and (constraints);
-
-    for (unsigned i = 0, sz = constraints.size(); i < sz; ++i) {
-        expr *c = constraints.get (i);
         expr *e1, *e2;
         if (m.is_implies(c, e1, e2)) {
             SASSERT (is_app (e1));
@@ -3613,7 +3607,6 @@ void context::add_constraints (unsigned level, const expr_ref& c)
                 }
                 else{
                     this->m_stats.m_num_lemmas_discarded++;
-                }
             }
         }
     }

src/muz/spacer/spacer_context.h

@@ -882,7 +882,7 @@ public:
     pob& get_root() const { return m_pob_queue.get_root(); }
 
     expr_ref get_constraints (unsigned lvl);
-    void add_constraints (unsigned lvl, const expr_ref& c);
+    void add_constraint (unsigned lvl, const expr_ref& c);
 
     void new_lemma_eh(pred_transformer &pt, lemma *lem);
 

src/muz/spacer/spacer_dl_interface.cpp

@@ -360,3 +360,7 @@ void dl_interface::add_callback(void *state,
                                 const datalog::t_unfold_eh unfold_eh){
     m_context->callbacks().push_back(alloc(user_callback, *m_context, state, new_lemma_eh, predecessor_eh, unfold_eh));
 }
+
+void dl_interface::add_constraint (expr *c, unsigned lvl){
+    m_context->add_constraint(c,lvl);
+}

src/muz/spacer/spacer_dl_interface.h

@@ -84,6 +84,8 @@ public:
                       const datalog::t_predecessor_eh predecessor_eh,
                       const datalog::t_unfold_eh unfold_eh);
 
+    void add_constraint (expr *c, unsigned lvl);
+
 };
 }