integrate lambda expressions

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

src/smt/theory_array_full.cpp

@@ -17,13 +17,13 @@ Revision History:
 
 --*/
 
-#include "smt/smt_context.h"
-#include "smt/theory_array_full.h"
+#include "util/stats.h"
 #include "ast/ast_ll_pp.h"
 #include "ast/ast_pp.h"
 #include "ast/ast_util.h"
 #include "ast/ast_smt2_pp.h"
-#include "util/stats.h"
+#include "smt/smt_context.h"
+#include "smt/theory_array_full.h"
 
 namespace smt {
 
@@ -54,11 +54,9 @@ namespace smt {
         set_prop_upward(v,d);
         d_full->m_maps.push_back(s);
         m_trail_stack.push(push_back_trail<theory_array, enode *, false>(d_full->m_maps));
-        ptr_vector<enode>::iterator it  = d->m_parent_selects.begin();
-        ptr_vector<enode>::iterator end = d->m_parent_selects.end();
-        for (; it != end; ++it) {
-            SASSERT(is_select(*it));
-            instantiate_select_map_axiom(*it, s);
+        for (enode* n : d->m_parent_selects) {
+            SASSERT(is_select(n));
+            instantiate_select_map_axiom(n, s);
         }
         set_prop_upward(s);
     }
@@ -67,15 +65,10 @@ namespace smt {
         bool result = false;
         var_data * d = m_var_data[v];
         var_data_full * d_full = m_var_data_full[v];
-        unsigned num_maps = d_full->m_parent_maps.size();
-        unsigned num_selects = d->m_parent_selects.size();
-        for (unsigned i = 0; i < num_maps; ++i) {
-            for (unsigned j = 0; j < num_selects; ++j) {
-                if (instantiate_select_map_axiom(d->m_parent_selects[j], d_full->m_parent_maps[i])) {
-                    result = true;
-                }
-            }
-        }
+        for (enode* pm : d_full->m_parent_maps) 
+            for (enode* ps : d->m_parent_selects) 
+                if (instantiate_select_map_axiom(ps, pm)) 
+                    result = true;                    
         return result;
     }
 
@@ -91,11 +84,9 @@ namespace smt {
         d_full->m_parent_maps.push_back(s);
         m_trail_stack.push(push_back_trail<theory_array, enode *, false>(d_full->m_parent_maps));
         if (!m_params.m_array_weak && !m_params.m_array_delay_exp_axiom && d->m_prop_upward) {
-            ptr_vector<enode>::iterator it  = d->m_parent_selects.begin();
-            ptr_vector<enode>::iterator end = d->m_parent_selects.end();
-            for (; it != end; ++it) {
-                if (!m_params.m_array_cg || (*it)->is_cgr()) {
-                    instantiate_select_map_axiom(*it, s);
+            for (enode * n : d->m_parent_selects) {
+                if (!m_params.m_array_cg || n->is_cgr()) {
+                    instantiate_select_map_axiom(n, s);
                 }                
             }
         }
@@ -118,20 +109,14 @@ namespace smt {
                 instantiate_axiom_map_for(v);
             }
             var_data_full * d2 = m_var_data_full[v];
-            ptr_vector<enode>::iterator it  = d->m_stores.begin();
-            ptr_vector<enode>::iterator end = d->m_stores.end();
-            for (; it != end; ++it) {
-                set_prop_upward(*it);
+            for (enode * n : d->m_stores) {
+                set_prop_upward(n);
             }
-            it   = d2->m_maps.begin();
-            end  = d2->m_maps.end();
-            for (; it != end; ++it) {
-                set_prop_upward(*it);
+            for (enode * n : d2->m_maps) {
+                set_prop_upward(n);
             }
-            it   = d2->m_consts.begin();
-            end  = d2->m_consts.end();
-            for (; it != end; ++it) {
-                set_prop_upward(*it);
+            for (enode * n : d2->m_consts) {
+                set_prop_upward(n);
             }
         }        
     }
@@ -180,12 +165,9 @@ namespace smt {
         m_trail_stack.push(push_back_trail<theory_array, enode *, false>(consts));
         consts.push_back(cnst);
         instantiate_default_const_axiom(cnst);
-
-        ptr_vector<enode>::iterator it  = d->m_parent_selects.begin();
-        ptr_vector<enode>::iterator end = d->m_parent_selects.end();
-        for (; it != end; ++it) {
-            SASSERT(is_select(*it));
-            instantiate_select_const_axiom(*it, cnst);
+        for (enode * n : d->m_parent_selects) {
+            SASSERT(is_select(n));
+            instantiate_select_const_axiom(n, cnst);
         }
     }
 
@@ -199,12 +181,9 @@ namespace smt {
         m_trail_stack.push(push_back_trail<theory_array, enode *, false>(as_arrays));
         as_arrays.push_back(arr);
         instantiate_default_as_array_axiom(arr);
-
-        ptr_vector<enode>::iterator it  = d->m_parent_selects.begin();
-        ptr_vector<enode>::iterator end = d->m_parent_selects.end();
-        for (; it != end; ++it) {
-            SASSERT(is_select(*it));
-            instantiate_select_as_array_axiom(*it, arr);
+        for (enode * n : d->m_parent_selects) {
+            SASSERT(is_select(n));
+            instantiate_select_as_array_axiom(n, arr);
         }
     }
 
@@ -257,6 +236,10 @@ namespace smt {
     }
 
     bool theory_array_full::internalize_term(app * n) {
+        context & ctx = get_context();
+        if (ctx.e_internalized(n)) {
+            return true;
+        }
         TRACE("array", tout << mk_pp(n, get_manager()) << "\n";);
 
         if (is_store(n) || is_select(n)) {
@@ -272,11 +255,10 @@ namespace smt {
         if (!internalize_term_core(n)) {
             return true;
         }
-        context & ctx = get_context();
 
         if (is_map(n) || is_array_ext(n)) {
-            for (unsigned i = 0; i < n->get_num_args(); ++i) {
-                enode* arg = ctx.get_enode(n->get_arg(i));
+            for (expr* e : *n) {
+                enode* arg = ctx.get_enode(e);
                 if (!is_attached_to_var(arg)) {
                     mk_var(arg);
                 }
@@ -300,8 +282,8 @@ namespace smt {
             add_parent_default(v_arg);
         }
         else if (is_map(n)) {
-            for (unsigned i = 0; i < n->get_num_args(); ++i) {
-                enode* arg = ctx.get_enode(n->get_arg(i));
+            for (expr* e : *n) {
+                enode* arg = ctx.get_enode(e);
                 theory_var v_arg = arg->get_th_var(get_id());
                 add_parent_map(v_arg, node);
             }
@@ -334,27 +316,17 @@ namespace smt {
         // v1 is the new root
         SASSERT(v1 == find(v1));
         var_data_full * d2 = m_var_data_full[v2];
-        ptr_vector<enode>::iterator it, end;
-
-        it   = d2->m_maps.begin();
-        end  = d2->m_maps.end();
-        for (; it != end; ++it) {
-            add_map(v1, *it);
+        for (enode * n : d2->m_maps) {
+            add_map(v1, n);
         }
-        it  = d2->m_parent_maps.begin();
-        end = d2->m_parent_maps.end();
-        for (; it != end; ++it) {
-            add_parent_map(v1, *it);
+        for (enode * n : d2->m_parent_maps) {
+            add_parent_map(v1, n);
         }
-        it = d2->m_consts.begin();
-        end = d2->m_consts.end();
-        for (; it != end; ++it) {
-            add_const(v1, *it);
+        for (enode * n : d2->m_consts) {
+            add_const(v1, n);
         }
-        it = d2->m_as_arrays.begin();
-        end = d2->m_as_arrays.end();
-        for (; it != end; ++it) {
-            add_as_array(v1, *it);
+        for (enode * n : d2->m_as_arrays) {
+            add_as_array(v1, n);
         }
         TRACE("array", 
               tout << mk_pp(get_enode(v1)->get_owner(), get_manager()) << "\n";
@@ -367,21 +339,13 @@ namespace smt {
         SASSERT(v != null_theory_var);
         v = find(v);
         var_data* d = m_var_data[v];
-        ptr_vector<enode>::iterator it, end;
-
-        it  = d->m_stores.begin();
-        end = d->m_stores.end();
-        for(; it != end; ++it) {
-            enode * store = *it;
+        for (enode * store : d->m_stores) {
             SASSERT(is_store(store));
             instantiate_default_store_axiom(store);
         }        
 
         if (!m_params.m_array_weak && !m_params.m_array_delay_exp_axiom && d->m_prop_upward) {
-            it  = d->m_parent_stores.begin();
-            end = d->m_parent_stores.end();
-            for (; it != end; ++it) {
-                enode* store = *it;
+            for (enode * store : d->m_parent_stores) {
                 SASSERT(is_store(store));
                 if (!m_params.m_array_cg || store->is_cgr()) {
                     instantiate_default_store_axiom(store);
@@ -399,23 +363,15 @@ namespace smt {
         v = find(v);
         var_data_full* d_full = m_var_data_full[v];
         var_data* d = m_var_data[v];
-        ptr_vector<enode>::iterator it  = d_full->m_consts.begin();
-        ptr_vector<enode>::iterator end = d_full->m_consts.end();
-        for (; it != end; ++it) {
-            instantiate_select_const_axiom(s, *it);
+        for (enode * n : d_full->m_consts) {
+            instantiate_select_const_axiom(s, n);
         }
-        it  = d_full->m_maps.begin();
-        end = d_full->m_maps.end();
-        for (; it != end; ++it) {
-            enode* map = *it;
+        for (enode * map : d_full->m_maps) {
             SASSERT(is_map(map));
             instantiate_select_map_axiom(s, map);
         }
         if (!m_params.m_array_weak && !m_params.m_array_delay_exp_axiom && d->m_prop_upward) {
-            it  = d_full->m_parent_maps.begin();
-            end = d_full->m_parent_maps.end();
-            for (; it != end; ++it) {
-                enode* map = *it;
+            for (enode * map : d_full->m_parent_maps) {
                 SASSERT(is_map(map));
                 if (!m_params.m_array_cg || map->is_cgr()) {
                     instantiate_select_map_axiom(s, map);
@@ -437,7 +393,7 @@ namespace smt {
             enode * arg = ctx.get_enode(n->get_arg(0));
             theory_var v = arg->get_th_var(get_id());
             SASSERT(v != null_theory_var);
-            add_parent_select(find(v), node);
+            add_parent_select(find(v), node);            
         }
         else if (is_default(n)) {
             enode * arg = ctx.get_enode(n->get_arg(0));
@@ -577,7 +533,14 @@ namespace smt {
         return try_assign_eq(val, def);
     }
 
+    /**
+     * instantiate f(ep1,ep2,..,ep_n) = default(as-array f)
+     * it is disabled to avoid as-array terms during search.
+     */
+
     bool theory_array_full::instantiate_default_as_array_axiom(enode* arr) {
+        return false;
+#if 0
         context& ctx = get_context();
         if (!ctx.add_fingerprint(this, 0, 1, &arr)) {
             return false;
@@ -595,6 +558,7 @@ namespace smt {
         ctx.internalize(def, false);
         ctx.internalize(val.get(), false);
         return try_assign_eq(val.get(), def);
+#endif
     }
 
     bool theory_array_full::has_large_domain(app* array_term) {