integrate lambda expressions

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

src/smt/proto_model/array_factory.cpp

@@ -17,11 +17,11 @@ Revision History:
 
 --*/
 
-#include "smt/proto_model/array_factory.h"
 #include "ast/array_decl_plugin.h"
-#include "smt/proto_model/proto_model.h"
-#include "model/func_interp.h"
 #include "ast/ast_pp.h"
+#include "model/func_interp.h"
+#include "smt/proto_model/array_factory.h"
+#include "smt/proto_model/proto_model.h"
 
 func_decl * mk_aux_decl_for_array_sort(ast_manager & m, sort * s) {
     ptr_buffer<sort> domain;
@@ -67,9 +67,13 @@ expr * array_factory::get_some_value(sort * s) {
         return *(set->begin());
     func_interp * fi;
     expr * val = mk_array_interp(s, fi);
+#if 0
     ptr_buffer<expr> args;
     get_some_args_for(s, args);
     fi->insert_entry(args.c_ptr(), m_model.get_some_value(get_array_range(s)));
+#else
+    fi->set_else(m_model.get_some_value(get_array_range(s)));
+#endif
     return val;
 }
 
@@ -143,9 +147,13 @@ expr * array_factory::get_fresh_value(sort * s) {
         // easy case
         func_interp * fi;
         expr * val = mk_array_interp(s, fi);
+#if 0
         ptr_buffer<expr> args;
         get_some_args_for(s, args);
         fi->insert_entry(args.c_ptr(), range_val);
+#else
+        fi->set_else(range_val);
+#endif
         return val;
     }
     else {

src/smt/proto_model/proto_model.cpp

@@ -18,13 +18,15 @@ Revision History:
 --*/
 #include "ast/ast_pp.h"
 #include "ast/ast_ll_pp.h"
-#include "ast/rewriter/var_subst.h"
 #include "ast/well_sorted.h"
 #include "ast/used_symbols.h"
+#include "ast/for_each_expr.h"
+#include "ast/rewriter/var_subst.h"
 #include "model/model_params.hpp"
 #include "model/model_v2_pp.h"
 #include "smt/proto_model/proto_model.h"
 
+
 proto_model::proto_model(ast_manager & m, params_ref const & p):
     model_core(m),
     m_eval(*this),
@@ -75,7 +77,7 @@ expr * proto_model::mk_some_interp_for(func_decl * d) {
         register_decl(d, r);
     }
     else {
-        func_interp * new_fi = alloc(func_interp, m_manager, d->get_arity());
+        func_interp * new_fi = alloc(func_interp, m, d->get_arity());
         new_fi->set_else(r);
         register_decl(d, new_fi);
     }
@@ -86,6 +88,7 @@ expr * proto_model::mk_some_interp_for(func_decl * d) {
 bool proto_model::eval(expr * e, expr_ref & result, bool model_completion) {
     m_eval.set_model_completion(model_completion);
     m_eval.set_expand_array_equalities(false);
+    TRACE("model_evaluator", model_v2_pp(tout, *this, true););
     try {
         m_eval(e, result);
         return true;
@@ -120,10 +123,10 @@ void proto_model::cleanup_func_interp(func_interp * fi, func_decl_set & found_au
     if (fi->is_partial())
         return;
     expr * fi_else = fi->get_else();
-    TRACE("model_bug", tout << "cleaning up:\n" << mk_pp(fi_else, m_manager) << "\n";);
+    TRACE("model_bug", tout << "cleaning up:\n" << mk_pp(fi_else, m) << "\n";);
 
     obj_map<expr, expr*> cache;
-    expr_ref_vector trail(m_manager);
+    expr_ref_vector trail(m);
     ptr_buffer<expr, 128> todo;
     ptr_buffer<expr> args;
     todo.push_back(fi_else);
@@ -165,7 +168,7 @@ void proto_model::cleanup_func_interp(func_interp * fi, func_decl_set & found_au
                     TRACE("model_bug", tout << f->get_name() << "\n";);
                     found_aux_fs.insert(f);
                 }
-                expr_ref new_t(m_manager);
+                expr_ref new_t(m);
                 new_t = m_rewrite.mk_app(f, args.size(), args.c_ptr());
                 if (t != new_t.get())
                     trail.push_back(new_t);
@@ -235,7 +238,7 @@ value_factory * proto_model::get_factory(family_id fid) {
 }
 
 void proto_model::freeze_universe(sort * s) {
-    SASSERT(m_manager.is_uninterp(s));
+    SASSERT(m.is_uninterp(s));
     m_user_sort_factory->freeze_universe(s);
 }
 
@@ -270,11 +273,11 @@ sort * proto_model::get_uninterpreted_sort(unsigned idx) const {
    in the model.
 */
 bool proto_model::is_finite(sort * s) const {
-    return m_manager.is_uninterp(s) && m_user_sort_factory->is_finite(s);
+    return m.is_uninterp(s) && m_user_sort_factory->is_finite(s);
 }
 
 expr * proto_model::get_some_value(sort * s) {
-    if (m_manager.is_uninterp(s)) {
+    if (m.is_uninterp(s)) {
         return m_user_sort_factory->get_some_value(s);
     }
     else {
@@ -288,7 +291,7 @@ expr * proto_model::get_some_value(sort * s) {
 }
 
 bool proto_model::get_some_values(sort * s, expr_ref & v1, expr_ref & v2) {
-    if (m_manager.is_uninterp(s)) {
+    if (m.is_uninterp(s)) {
         return m_user_sort_factory->get_some_values(s, v1, v2);
     }
     else {
@@ -302,7 +305,7 @@ bool proto_model::get_some_values(sort * s, expr_ref & v1, expr_ref & v2) {
 }
 
 expr * proto_model::get_fresh_value(sort * s) {
-    if (m_manager.is_uninterp(s)) {
+    if (m.is_uninterp(s)) {
         return m_user_sort_factory->get_fresh_value(s);
     }
     else {
@@ -318,8 +321,8 @@ expr * proto_model::get_fresh_value(sort * s) {
 }
 
 void proto_model::register_value(expr * n) {
-    sort * s = m_manager.get_sort(n);
-    if (m_manager.is_uninterp(s)) {
+    sort * s = m.get_sort(n);
+    if (m.is_uninterp(s)) {
         m_user_sort_factory->register_value(n);
     }
     else {
@@ -374,15 +377,15 @@ void proto_model::complete_partial_funcs(bool use_fresh) {
 
 model * proto_model::mk_model() {
     TRACE("proto_model", model_v2_pp(tout << "mk_model\n", *this););
-    model * m = alloc(model, m_manager);
+    model * mdl = alloc(model, m);
 
     for (auto const& kv : m_interp) {
-        m->register_decl(kv.m_key, kv.m_value);
+        mdl->register_decl(kv.m_key, kv.m_value);
     }
 
     for (auto const& kv : m_finterp) {
-        m->register_decl(kv.m_key, kv.m_value);
-        m_manager.dec_ref(kv.m_key);
+        mdl->register_decl(kv.m_key, kv.m_value);
+        m.dec_ref(kv.m_key);
     }
 
     m_finterp.reset(); // m took the ownership of the func_interp's
@@ -390,10 +393,11 @@ model * proto_model::mk_model() {
     unsigned sz = get_num_uninterpreted_sorts();
     for (unsigned i = 0; i < sz; i++) {
         sort * s = get_uninterpreted_sort(i);
-        TRACE("proto_model", tout << "copying uninterpreted sorts...\n" << mk_pp(s, m_manager) << "\n";);
+        TRACE("proto_model", tout << "copying uninterpreted sorts...\n" << mk_pp(s, m) << "\n";);
         ptr_vector<expr> const& buf = get_universe(s);
-        m->register_usort(s, buf.size(), buf.c_ptr());
+        mdl->register_usort(s, buf.size(), buf.c_ptr());
     }
 
-    return m;
+    return mdl;
 }
+

src/smt/proto_model/proto_model.h

@@ -38,6 +38,7 @@ Revision History:
 #include "util/params.h"
 #include "ast/rewriter/th_rewriter.h"
 
+
 class proto_model : public model_core {
     plugin_manager<value_factory> m_factories;
     user_sort_factory *           m_user_sort_factory;