fix #2468, adding assignment phase heuristic

Signed-off-by: Nikolaj Bjorner <[email protected]>

Author: NikolajBjorner

src/ast/array_decl_plugin.h

@@ -210,6 +210,10 @@ class array_util : public array_recognizers {
         return r;
     }
 
+    app * mk_default(expr * a) {
+        return m_manager.mk_app(m_fid, OP_ARRAY_DEFAULT, 0, nullptr, 1, &a);
+    }
+
     app * mk_const_array(sort * s, expr * v) {
         parameter param(s);
         return m_manager.mk_app(m_fid, OP_CONST_ARRAY, 1, &param, 1, &v);
@@ -251,6 +255,14 @@ class array_util : public array_recognizers {
         parameter param(f);
         return m_manager.mk_app(m_fid, OP_AS_ARRAY, 1, &param, 0, nullptr, nullptr);
     }
+
+    sort* get_array_range_rec(sort* s) {
+        while (is_array(s)) {
+            s = get_array_range(s);
+        }
+        return s;
+    }
+
 };
 
 

src/ast/datatype_decl_plugin.cpp

@@ -450,6 +450,19 @@ namespace datatype {
                 m_manager->raise_exception("datatype is not co-variant");
             }
 
+            array_util autil(m);
+            for (sort* s : sorts) {
+                for (constructor const* c : get_def(s)) {
+                    for (accessor const* a : *c) {
+                        if (autil.is_array(a->range())) {
+                            if (sorts.contains(get_array_range(a->range()))) {
+                                m_has_nested_arrays = true;
+                            }
+                        }                    
+                    }
+                }
+            }
+            
             u().compute_datatype_size_functions(m_def_block);
             for (symbol const& s : m_def_block) {
                 sort_ref_vector ps(m);
@@ -892,10 +905,13 @@ namespace datatype {
         for (unsigned i = 0; i < n; ++i) {
             get_subsorts(get_array_domain(s, i), subsorts);
         }
+        if (!is_datatype(get_array_range(s))) {
+            get_subsorts(get_array_range(s), subsorts);
+        }
         for (sort* r : subsorts) {
             if (mark.is_marked(r)) return false;
         }
-        return is_covariant(mark, subsorts, get_array_range(s));
+        return true;
     }
 
     def const& util::get_def(sort* s) const {
@@ -1115,6 +1131,7 @@ namespace datatype {
 
         ptr_vector<func_decl> const& constructors = *get_datatype_constructors(ty);
         unsigned sz = constructors.size();
+        array_util autil(m);
         TRACE("util_bug", tout << "get-non-rec constructor: " << sort_ref(ty, m) << "\n";
               tout << "forbidden: ";
               for (sort* s : forbidden_set) tout << sort_ref(s, m) << " ";
@@ -1129,7 +1146,7 @@ namespace datatype {
             TRACE("util_bug", tout << "checking " << sort_ref(ty, m) << ": " << func_decl_ref(c, m) << "\n";);
             unsigned num_args = c->get_arity();
             unsigned i = 0;
-            for (; i < num_args && !is_datatype(c->get_domain(i)); i++);
+            for (; i < num_args && !is_datatype(autil.get_array_range_rec(c->get_domain(i))); i++);
             if (i == num_args) {
                 TRACE("util_bug", tout << "found non-rec " << func_decl_ref(c, m) << "\n";);
                 return c;
@@ -1142,7 +1159,7 @@ namespace datatype {
             unsigned num_args = c->get_arity();
             unsigned i = 0;
             for (; i < num_args; i++) {
-                sort * T_i = c->get_domain(i);
+                sort * T_i = autil.get_array_range_rec(c->get_domain(i));
                 TRACE("util_bug", tout << "c: " << i << " " << sort_ref(T_i, m) << "\n";);
                 if (!is_datatype(T_i)) {
                     TRACE("util_bug", tout << sort_ref(T_i, m) << " is not a datatype\n";);

src/ast/datatype_decl_plugin.h

@@ -210,13 +210,14 @@ namespace datatype {
             unsigned                 m_id_counter;
             svector<symbol>          m_def_block;
             unsigned                 m_class_id;
+            mutable bool             m_has_nested_arrays;
 
             void inherit(decl_plugin* other_p, ast_translation& tr) override;
 
             void log_axiom_definitions(symbol const& s, sort * new_sort);
 
         public:
-            plugin(): m_id_counter(0), m_class_id(0) {}
+            plugin(): m_id_counter(0), m_class_id(0), m_has_nested_arrays(false) {}
             ~plugin() override;
 
             void finalize() override;
@@ -254,6 +255,8 @@ namespace datatype {
             unsigned get_axiom_base_id(symbol const& s) { return m_axiom_bases[s]; }
             util & u() const;
 
+            bool has_nested_arrays() const { return m_has_nested_arrays; }
+
         private:
             bool is_value_visit(expr * arg, ptr_buffer<app> & todo) const;
 
@@ -353,6 +356,7 @@ namespace datatype {
         func_decl * get_accessor_constructor(func_decl * accessor);
         func_decl * get_recognizer_constructor(func_decl * recognizer) const;
         func_decl * get_update_accessor(func_decl * update) const;
+        bool has_nested_arrays() const { return m_plugin->has_nested_arrays(); }
         family_id get_family_id() const { return m_family_id; }
         bool are_siblings(sort * s1, sort * s2);
         bool is_func_decl(op_kind k, unsigned num_params, parameter const* params, func_decl* f);

src/smt/params/smt_params.h

@@ -39,7 +39,8 @@ enum phase_selection {
     PS_CACHING_CONSERVATIVE,
     PS_CACHING_CONSERVATIVE2, // similar to the previous one, but alternated default config from time to time.
     PS_RANDOM,
-    PS_OCCURRENCE
+    PS_OCCURRENCE,
+    PS_THEORY
 };
 
 enum restart_strategy {

src/smt/params/smt_params_helper.pyg

@@ -10,7 +10,7 @@ def_module_params(module_name='smt',
                           ('quasi_macros', BOOL, False, 'try to find universally quantified formulas that are quasi-macros'),
                           ('restricted_quasi_macros', BOOL, False, 'try to find universally quantified formulas that are restricted quasi-macros'),
                           ('ematching', BOOL, True, 'E-Matching based quantifier instantiation'),
-                          ('phase_selection', UINT, 3, 'phase selection heuristic: 0 - always false, 1 - always true, 2 - phase caching, 3 - phase caching conservative, 4 - phase caching conservative 2, 5 - random, 6 - number of occurrences'),
+                          ('phase_selection', UINT, 3, 'phase selection heuristic: 0 - always false, 1 - always true, 2 - phase caching, 3 - phase caching conservative, 4 - phase caching conservative 2, 5 - random, 6 - number of occurrences, 7 - theory'),
                           ('restart_strategy', UINT, 1, '0 - geometric, 1 - inner-outer-geometric, 2 - luby, 3 - fixed, 4 - arithmetic'),
                           ('restart_factor', DOUBLE, 1.1, 'when using geometric (or inner-outer-geometric) progression of restarts, it specifies the constant used to multiply the current restart threshold'),
                           ('case_split', UINT, 1, '0 - case split based on variable activity, 1 - similar to 0, but delay case splits created during the search, 2 - similar to 0, but cache the relevancy, 3 - case split based on relevancy (structural splitting), 4 - case split on relevancy and activity, 5 - case split on relevancy and current goal, 6 - activity-based case split with theory-aware branching activity'),

src/smt/smt_arith_value.cpp

@@ -17,6 +17,7 @@ Revision History:
 
 --*/
 
+#include "ast/ast_pp.h"
 #include "smt/smt_arith_value.h"
 
 namespace smt {
@@ -50,6 +51,7 @@ namespace smt {
             next = next->get_next();
         }
         while (n != next);
+        CTRACE("arith_value", !found, tout << "value not found for " << mk_pp(e, m_ctx->get_manager()) << "\n";);
         return found;
     }
 
@@ -69,6 +71,7 @@ namespace smt {
             next = next->get_next();
         }
         while (n != next);
+        CTRACE("arith_value", !found, tout << "value not found for " << mk_pp(e, m_ctx->get_manager()) << "\n";);
         return found;
     }
 
@@ -79,6 +82,7 @@ namespace smt {
         if (m_tha) return m_tha->get_upper(n, up, is_strict);
         if (m_thi) return m_thi->get_upper(n, up, is_strict);
         if (m_thr) return m_thr->get_upper(n, up, is_strict);
+        TRACE("arith_value", tout << "value not found for " << mk_pp(e, m_ctx->get_manager()) << "\n";);
         return false;
     }
 
@@ -89,6 +93,7 @@ namespace smt {
         if (m_tha) return m_tha->get_lower(n, up, is_strict);
         if (m_thi) return m_thi->get_lower(n, up, is_strict);
         if (m_thr) return m_thr->get_lower(n, up, is_strict);
+        TRACE("arith_value", tout << "value not found for " << mk_pp(e, m_ctx->get_manager()) << "\n";);
         return false;
     }
 
@@ -99,6 +104,7 @@ namespace smt {
         if (m_tha && m_tha->get_value(n, _val) && a.is_numeral(_val, val)) return true;
         if (m_thi && m_thi->get_value(n, _val) && a.is_numeral(_val, val)) return true;
         if (m_thr && m_thr->get_value(n, val)) return true;
+        TRACE("arith_value", tout << "value not found for " << mk_pp(e, m_ctx->get_manager()) << "\n";);
         return false;
     }
 
@@ -115,6 +121,7 @@ namespace smt {
             next = next->get_next();
         }
         while (next != n);
+        TRACE("arith_value", tout << "value not found for " << mk_pp(e, m_ctx->get_manager()) << "\n";);
         return false;
     }
 

src/smt/smt_context.cpp

@@ -1849,6 +1849,16 @@ namespace smt {
             }
             else {
                 switch (m_fparams.m_phase_selection) {
+                case PS_THEORY: 
+                    if (d.is_theory_atom()) {
+                        theory * th = m_theories.get_plugin(d.get_theory());
+                        lbool ph = th->get_phase(var);
+                        if (ph != l_undef) {
+                            is_pos = ph == l_true;
+                            break;
+                        }
+                    }
+                    Z3_fallthrough;
                 case PS_CACHING:
                 case PS_CACHING_CONSERVATIVE:
                 case PS_CACHING_CONSERVATIVE2: