Merge branch 'master' of https://github.com/Z3Prover/z3 into nsb/master

scripts/mk_util.py

@@ -75,7 +75,7 @@ VER_MAJOR=None
 VER_MINOR=None
 VER_BUILD=None
 VER_REVISION=None
-PREFIX=os.path.split(os.path.split(os.path.split(PYTHON_PACKAGE_DIR)[0])[0])[0]
+PREFIX=sys.prefix
 GMP=False
 FOCI2=False
 FOCI2LIB=''
@@ -531,6 +531,7 @@ if os.name == 'nt':
 elif os.name == 'posix':
     if os.uname()[0] == 'Darwin':
         IS_OSX=True
+        PREFIX="/usr/local"
     elif os.uname()[0] == 'Linux':
         IS_LINUX=True
     elif os.uname()[0] == 'FreeBSD':
@@ -1984,6 +1985,7 @@ def mk_config():
             print('Prefix:         %s' % PREFIX)
             print('64-bit:         %s' % is64())
             print('FP math:        %s' % FPMATH)
+            print("Python pkg dir: %s" % PYTHON_PACKAGE_DIR)
             if GPROF:
                 print('gprof:          enabled')
             print('Python version: %s' % distutils.sysconfig.get_python_version())
@@ -2074,8 +2076,6 @@ def mk_makefile():
     # Finalize
     if VERBOSE:
         print("Makefile was successfully generated.")
-        if not IS_WINDOWS:
-            print("  python packages dir: %s" % PYTHON_PACKAGE_DIR)
         if DEBUG_MODE:
             print("  compilation mode: Debug")
         else:

src/api/java/Model.java

@@ -56,7 +56,7 @@ public class Model extends Z3Object
                         Native.getRange(getContext().nCtx(), f.getNativeObject())) == Z3_sort_kind.Z3_ARRAY_SORT
                         .toInt())
             throw new Z3Exception(
-                    "Non-zero arity functions and arrays have FunctionInterpretations as a model. Use FuncInterp.");
+                    "Non-zero arity functions and arrays have FunctionInterpretations as a model. Use getFuncInterp.");
 
         long n = Native.modelGetConstInterp(getContext().nCtx(), getNativeObject(),
                 f.getNativeObject());
@@ -101,7 +101,7 @@ public class Model extends Z3Object
             } else
             {
                 throw new Z3Exception(
-                        "Constant functions do not have a function interpretation; use ConstInterp");
+                        "Constant functions do not have a function interpretation; use getConstInterp");
             }
         } else
         {

src/api/python/z3.py

@@ -284,6 +284,9 @@ class AstRef(Z3PPObject):
     def __repr__(self):
         return obj_to_string(self)
 
+    def __hash__(self):
+        return self.hash()
+
     def sexpr(self):
         """Return an string representing the AST node in s-expression notation.
         

src/ast/fpa/fpa2bv_converter.cpp

@@ -36,10 +36,6 @@ fpa2bv_converter::fpa2bv_converter(ast_manager & m) :
     m_mpf_manager(m_util.fm()),
     m_mpz_manager(m_mpf_manager.mpz_manager()),
     m_hi_fp_unspecified(true),
-    m_min_pn_zeros(0, m),
-    m_min_np_zeros(0, m),
-    m_max_pn_zeros(0, m),
-    m_max_np_zeros(0, m),
     m_extra_assertions(m) {
     m_plugin = static_cast<fpa_decl_plugin*>(m.get_plugin(m.mk_family_id("fpa")));
 }
@@ -1154,22 +1150,22 @@ expr_ref fpa2bv_converter::mk_min_unspecified(func_decl * f, expr * x, expr * y)
         // The hardware interpretation is -0.0.
         mk_nzero(f, res);
     else {
-        if (m_min_pn_zeros == 0) {
+        std::pair<app*, app*> decls(0, 0);
-            m_min_pn_zeros = m.mk_fresh_const(0, m_bv_util.mk_sort(1));
+        if (!m_specials.find(f, decls)) {
-            m_decls_to_hide.insert_if_not_there(m_min_pn_zeros->get_decl());
+            decls.first = m.mk_fresh_const(0, m_bv_util.mk_sort(1));
-        }
+            decls.second = m.mk_fresh_const(0, m_bv_util.mk_sort(1));
-
+            m_specials.insert(f, decls);
-        if (m_min_np_zeros == 0) {
+            m.inc_ref(f);
-            m_min_np_zeros = m.mk_fresh_const(0, m_bv_util.mk_sort(1));
+            m.inc_ref(decls.first);
-            m_decls_to_hide.insert_if_not_there(m_min_np_zeros->get_decl());
+            m.inc_ref(decls.second);
         }
 
         expr_ref pn(m), np(m);
-        mk_fp(m_min_pn_zeros,
+        mk_fp(decls.first,
               m_bv_util.mk_numeral(0, ebits),
               m_bv_util.mk_numeral(0, sbits - 1),
               pn);
-        mk_fp(m_min_np_zeros,
+        mk_fp(decls.second,
               m_bv_util.mk_numeral(0, ebits),
               m_bv_util.mk_numeral(0, sbits - 1),
               np);
@@ -1243,22 +1239,22 @@ expr_ref fpa2bv_converter::mk_max_unspecified(func_decl * f, expr * x, expr * y)
         // The hardware interpretation is +0.0.
         mk_pzero(f, res);
     else {
-        if (m_max_pn_zeros == 0) {
+        std::pair<app*, app*> decls(0, 0);
-            m_max_pn_zeros = m.mk_fresh_const(0, m_bv_util.mk_sort(1));
+        if (!m_specials.find(f, decls)) {
-            m_decls_to_hide.insert_if_not_there(m_max_pn_zeros->get_decl());
+            decls.first = m.mk_fresh_const(0, m_bv_util.mk_sort(1));
-        }
+            decls.second = m.mk_fresh_const(0, m_bv_util.mk_sort(1));
-
+            m_specials.insert(f, decls);
-        if (m_max_np_zeros == 0) {
+            m.inc_ref(f);
-            m_max_np_zeros = m.mk_fresh_const(0, m_bv_util.mk_sort(1));
+            m.inc_ref(decls.first);
-            m_decls_to_hide.insert_if_not_there(m_max_np_zeros->get_decl());
+            m.inc_ref(decls.second);
         }
 
         expr_ref pn(m), np(m);
-        mk_fp(m_max_pn_zeros,
+        mk_fp(decls.first,
               m_bv_util.mk_numeral(0, ebits),
               m_bv_util.mk_numeral(0, sbits - 1),
               pn);
-        mk_fp(m_max_np_zeros,
+        mk_fp(decls.second,
               m_bv_util.mk_numeral(0, ebits),
               m_bv_util.mk_numeral(0, sbits - 1),
               np);
@@ -3839,14 +3835,16 @@ void fpa2bv_converter::round(sort * s, expr_ref & bv_rm, expr_ref & sgn, expr_re
     TRACE("fpa2bv_round", tout << "ROUND = " << mk_ismt2_pp(result, m) << std::endl; );
 }
 
-
 void fpa2bv_converter::reset(void) {
     dec_ref_map_key_values(m, m_const2bv);
     dec_ref_map_key_values(m, m_rm_const2bv);
     dec_ref_map_key_values(m, m_uf2bvuf);
-    m_min_np_zeros = 0;
+    for (obj_map<func_decl, std::pair<app*, app*> >::iterator it = m_specials.begin();
-    m_min_pn_zeros = 0;
+         it != m_specials.end();
-    m_max_np_zeros = 0;
+         it++) {
-    m_max_pn_zeros = 0;
+        m.dec_ref(it->m_key);
+        m.dec_ref(it->m_value.first);
+        m.dec_ref(it->m_value.second);
+    }
     m_extra_assertions.reset();
 }

src/ast/fpa/fpa2bv_converter.h

@@ -54,12 +54,10 @@ protected:
     obj_map<func_decl, expr*>  m_const2bv;
     obj_map<func_decl, expr*>  m_rm_const2bv;
     obj_map<func_decl, func_decl*>  m_uf2bvuf;
-    obj_hashtable<func_decl>   m_decls_to_hide;
 
-    app_ref                    m_min_pn_zeros;
+    obj_map<func_decl, std::pair<app *, app *> > m_specials;
-    app_ref                    m_min_np_zeros;
+
-    app_ref                    m_max_pn_zeros;
+    friend class fpa2bv_model_converter;
-    app_ref                    m_max_np_zeros;
 
 public:
     fpa2bv_converter(ast_manager & m);
@@ -153,11 +151,6 @@ public:
     expr_ref mk_to_sbv_unspecified(unsigned width);
     expr_ref mk_to_real_unspecified();
 
-    obj_map<func_decl, expr*> const & const2bv() const { return m_const2bv; }
-    obj_map<func_decl, expr*> const & rm_const2bv() const { return m_rm_const2bv; }
-    obj_map<func_decl, func_decl*> const & uf2bvuf() const { return m_uf2bvuf; }
-    obj_hashtable<func_decl> const & decls_to_hide() const { return m_decls_to_hide; }
-
     void reset(void);
 
     void dbg_decouple(const char * prefix, expr_ref & e);

src/ast/rewriter/arith_rewriter.cpp

@@ -318,6 +318,7 @@ br_status arith_rewriter::reduce_power(expr * arg1, expr * arg2, op_kind kind, e
 }
 
 br_status arith_rewriter::mk_le_ge_eq_core(expr * arg1, expr * arg2, op_kind kind, expr_ref & result) {
+    expr *orig_arg1 = arg1, *orig_arg2 = arg2;
     expr_ref new_arg1(m());
     expr_ref new_arg2(m());
     if ((is_zero(arg1) && is_reduce_power_target(arg2, kind == EQ)) ||
@@ -407,7 +408,11 @@ br_status arith_rewriter::mk_le_ge_eq_core(expr * arg1, expr * arg2, op_kind kin
             st = BR_DONE;
         }
     }
-    if (st != BR_FAILED) {
+    if (st == BR_DONE && arg1 == orig_arg1 && arg2 == orig_arg2) {
+        // Nothing new; return BR_FAILED to avoid rewriting loops.
+        return BR_FAILED;
+    }
+    else if (st != BR_FAILED) {
         switch (kind) {
         case LE: result = m_util.mk_le(arg1, arg2); return BR_DONE;
         case GE: result = m_util.mk_ge(arg1, arg2); return BR_DONE;

src/ast/rewriter/fpa_rewriter.cpp

@@ -439,7 +439,7 @@ br_status fpa_rewriter::mk_min(expr * arg1, expr * arg2, expr_ref & result) {
     if (m_util.is_numeral(arg1, v1) && m_util.is_numeral(arg2, v2)) {
         if (m_fm.is_zero(v1) && m_fm.is_zero(v2) && m_fm.sgn(v1) != m_fm.sgn(v2)) {
             result = m().mk_app(get_fid(), OP_FPA_INTERNAL_MIN_UNSPECIFIED, arg1, arg2);
-            return BR_DONE;
+            return BR_REWRITE1;
         }
         else {
             scoped_mpf r(m_fm);
@@ -474,7 +474,7 @@ br_status fpa_rewriter::mk_max(expr * arg1, expr * arg2, expr_ref & result) {
     if (m_util.is_numeral(arg1, v1) && m_util.is_numeral(arg2, v2)) {
         if (m_fm.is_zero(v1) && m_fm.is_zero(v2) && m_fm.sgn(v1) != m_fm.sgn(v2)) {
             result = m().mk_app(get_fid(), OP_FPA_INTERNAL_MAX_UNSPECIFIED, arg1, arg2);
-            return BR_DONE;
+            return BR_REWRITE1;
         }
         else {
             scoped_mpf r(m_fm);

src/cmd_context/cmd_context.cpp

@@ -1604,16 +1604,13 @@ void cmd_context::mk_solver() {
     bool proofs_enabled, models_enabled, unsat_core_enabled;
     params_ref p;
     m_params.get_solver_params(m(), p, proofs_enabled, models_enabled, unsat_core_enabled);
-    if(produce_interpolants()){
+    if (produce_interpolants() && m_interpolating_solver_factory) {
-        SASSERT(m_interpolating_solver_factory);
         m_solver = (*m_interpolating_solver_factory)(m(), p, true /* must have proofs */, models_enabled, unsat_core_enabled, m_logic);
     }
     else
         m_solver = (*m_solver_factory)(m(), p, proofs_enabled, models_enabled, unsat_core_enabled, m_logic);
 }
 
-
-
 void cmd_context::set_interpolating_solver_factory(solver_factory * f) {
   SASSERT(!has_manager());
   m_interpolating_solver_factory   = f;

src/model/model_evaluator.cpp

@@ -73,6 +73,11 @@ struct evaluator_cfg : public default_rewriter_cfg {
         
     ast_manager & m() const { return m_model.get_manager(); }
 
+    bool evaluate(func_decl* f, unsigned num, expr * const * args, expr_ref & result) {
+        func_interp* fi = m_model.get_func_interp(f);
+        return (fi != 0) && eval_fi(fi, num, args, result);
+    }
+
     // Try to use the entries to quickly evaluate the fi
     bool eval_fi(func_interp * fi, unsigned num, expr * const * args, expr_ref & result) {
         if (fi->num_entries() == 0)
@@ -101,8 +106,7 @@ struct evaluator_cfg : public default_rewriter_cfg {
     br_status reduce_app(func_decl * f, unsigned num, expr * const * args, expr_ref & result, proof_ref & result_pr) {
         result_pr = 0;
         family_id fid = f->get_family_id();
-        if (fid == null_family_id) {
+        if (fid == null_family_id && num == 0) {
-            if (num == 0) {
             expr * val = m_model.get_const_interp(f);
             if (val != 0) {
                 result = val;
@@ -118,15 +122,8 @@ struct evaluator_cfg : public default_rewriter_cfg {
             }
             return BR_FAILED;
         }
-            SASSERT(num > 0);
+
-            func_interp * fi = m_model.get_func_interp(f);
+        br_status st = BR_FAILED;
-            if (fi != 0 && eval_fi(fi, num, args, result)) {
-                TRACE("model_evaluator", tout << "reduce_app " << f->get_name() << "\n";
-                      for (unsigned i = 0; i < num; i++) tout << mk_ismt2_pp(args[i], m()) << "\n";
-                      tout << "---->\n" << mk_ismt2_pp(result, m()) << "\n";);
-                return BR_DONE;
-            }
-        }
 
         if (fid == m_b_rw.get_fid()) {
             decl_kind k = f->get_decl_kind();
@@ -134,7 +131,6 @@ struct evaluator_cfg : public default_rewriter_cfg {
                 // theory dispatch for =
                 SASSERT(num == 2);
                 family_id s_fid = m().get_sort(args[0])->get_family_id();
-                br_status st = BR_FAILED;
                 if (s_fid == m_a_rw.get_fid())
                     st = m_a_rw.mk_eq_core(args[0], args[1], result);
                 else if (s_fid == m_bv_rw.get_fid())
@@ -148,25 +144,38 @@ struct evaluator_cfg : public default_rewriter_cfg {
             }
             return m_b_rw.mk_app_core(f, num, args, result);
         }
+
         if (fid == m_a_rw.get_fid())
-            return m_a_rw.mk_app_core(f, num, args, result);
+            st = m_a_rw.mk_app_core(f, num, args, result);
-        if (fid == m_bv_rw.get_fid())
+        else if (fid == m_bv_rw.get_fid())
-            return m_bv_rw.mk_app_core(f, num, args, result);
+            st = m_bv_rw.mk_app_core(f, num, args, result);
-        if (fid == m_ar_rw.get_fid()) 
+        else if (fid == m_ar_rw.get_fid()) 
-            return m_ar_rw.mk_app_core(f, num, args, result);
+            st = m_ar_rw.mk_app_core(f, num, args, result);
-        if (fid == m_dt_rw.get_fid())
+        else if (fid == m_dt_rw.get_fid())
-            return m_dt_rw.mk_app_core(f, num, args, result);
+            st = m_dt_rw.mk_app_core(f, num, args, result);
-        if (fid == m_pb_rw.get_fid())
+        else if (fid == m_pb_rw.get_fid())
-            return m_pb_rw.mk_app_core(f, num, args, result);
+            st = m_pb_rw.mk_app_core(f, num, args, result);
-        if (fid == m_f_rw.get_fid())
+        else if (fid == m_f_rw.get_fid())
-            return m_f_rw.mk_app_core(f, num, args, result);
+            st = m_f_rw.mk_app_core(f, num, args, result);
-        return BR_FAILED;
+        else if (evaluate(f, num, args, result)) {
+            TRACE("model_evaluator", tout << "reduce_app " << f->get_name() << "\n";
+                  for (unsigned i = 0; i < num; i++) tout << mk_ismt2_pp(args[i], m()) << "\n";
+                  tout << "---->\n" << mk_ismt2_pp(result, m()) << "\n";);
+            return BR_DONE;
+        }
+        if (st == BR_DONE && is_app(result)) {
+            app* a = to_app(result);
+            if (evaluate(a->get_decl(), a->get_num_args(), a->get_args(), result)) {
+                return BR_DONE;
+            }
+        }
+        TRACE("model_evaluator", tout << f->get_name() << "\n";);
+        return st;
     }
 
     bool get_macro(func_decl * f, expr * & def, quantifier * & q, proof * & def_pr) { 
-        if (f->get_family_id() == null_family_id) {
-            func_interp * fi = m_model.get_func_interp(f);
 
+        func_interp * fi = m_model.get_func_interp(f);        
         if (fi != 0) {
             if (fi->is_partial()) {
                 if (m_model_completion) {
@@ -178,13 +187,12 @@ struct evaluator_cfg : public default_rewriter_cfg {
                     return false;
                 }
             }            
-                
             def    = fi->get_interp();
             SASSERT(def != 0);
             return true;
         }
 
-            if (m_model_completion) {
+        if (f->get_family_id() == null_family_id && m_model_completion) {
             sort * s   = f->get_range();
             expr * val = m_model.get_some_value(s);
             func_interp * new_fi = alloc(func_interp, m(), f->get_arity());
@@ -193,10 +201,10 @@ struct evaluator_cfg : public default_rewriter_cfg {
             def = val;
             return true;
         }
-        }
         return false;
     }
 
+    
     bool max_steps_exceeded(unsigned num_steps) const { 
         cooperate("model evaluator");
         if (memory::get_allocation_size() > m_max_memory)

src/opt/maxres.cpp

@@ -188,6 +188,7 @@ public:
     }
 
     lbool mus_solver() {
+        lbool is_sat = l_true;
         init();
         init_local();
         trace();
@@ -198,7 +199,7 @@ public:
                   tout << "\n";
                   display(tout);
                   );
-            lbool is_sat = check_sat_hill_climb(m_asms);
+            is_sat = check_sat_hill_climb(m_asms);
             if (m_cancel) {
                 return l_undef;
             }
@@ -833,9 +834,7 @@ public:
                 s().assert_expr(m_asms[i].get());
             }
         }
-        else {
+        // else: there is only a single assignment to these soft constraints.
-            maxsmt_solver_base::commit_assignment();
-        }
     }
 
     void verify_core(exprs const& core) {

src/opt/maxsmt.cpp

@@ -159,12 +159,7 @@ namespace opt {
         symbol const& maxsat_engine = m_c.maxsat_engine();
         IF_VERBOSE(1, verbose_stream() << "(maxsmt)\n";);
         TRACE("opt", tout << "maxsmt\n";);
-        if (m_soft_constraints.empty()) {
+        if (m_soft_constraints.empty() || maxsat_engine == symbol("maxres")) {            
-            TRACE("opt", tout << "no constraints\n";);
-            m_msolver = 0;
-            is_sat = s().check_sat(0, 0);
-        }
-        else if (maxsat_engine == symbol("maxres")) {            
             m_msolver = mk_maxres(m_c, m_weights, m_soft_constraints);
         }
         else if (maxsat_engine == symbol("pd-maxres")) {            

src/smt/smt_model_generator.cpp

@@ -400,7 +400,12 @@ namespace smt {
        \brief Return true if the interpretation of the function should be included in the model.
     */
     bool model_generator::include_func_interp(func_decl * f) const {
-        return f->get_family_id() == null_family_id;
+        family_id fid = f->get_family_id();
+        if (fid == null_family_id) return true;
+        if (fid == m_manager.get_basic_family_id()) return false;
+        theory * th   = m_context->get_theory(fid);
+        if (!th) return true;
+        return th->include_func_interp(f);
     }
     
     /**

src/smt/smt_theory.h

@@ -412,6 +412,10 @@ namespace smt {
             return 0;
         }
 
+        virtual bool include_func_interp(func_decl* f) {
+            return false;
+        }
+
         // -----------------------------------
         //
         // Model checker

src/smt/theory_arith_aux.h

@@ -1346,7 +1346,7 @@ namespace smt {
                 empty_column ||
                 (unbounded_gain(max_gain) == (x_i == null_theory_var)));
         
-        return !empty_column && safe_gain(min_gain, max_gain);
+        return safe_gain(min_gain, max_gain);
     }
 
     template<typename Ext>
@@ -1557,14 +1557,12 @@ namespace smt {
                     // variable cannot be used for max/min.
                     continue; 
                 }
-                bool picked_var = pick_var_to_leave(curr_x_j, curr_inc, curr_a_ij, 
+                bool safe_to_leave = pick_var_to_leave(curr_x_j, curr_inc, curr_a_ij, 
                                                     curr_min_gain, curr_max_gain, 
                                                     has_shared, curr_x_i);
 
                 
-                SASSERT(!picked_var || safe_gain(curr_min_gain, curr_max_gain));
+                if (!safe_to_leave) {
-                
-                if (!safe_gain(curr_min_gain, curr_max_gain)) {
                     TRACE("opt", tout << "no variable picked\n";);
                     has_bound = true;
                     best_efforts++;

src/smt/theory_bv.cpp

@@ -1283,6 +1283,21 @@ namespace smt {
         theory::reset_eh();
     }
 
+    bool theory_bv::include_func_interp(func_decl* f) {
+        SASSERT(f->get_family_id() == get_family_id());
+        switch (f->get_decl_kind()) {
+        case OP_BSDIV0:
+        case OP_BUDIV0:
+        case OP_BSREM0:
+        case OP_BUREM0:       
+        case OP_BSMOD0:        
+            return true;
+        default:
+            return false;
+        }
+        return false;
+    }
+
     theory_bv::theory_bv(ast_manager & m, theory_bv_params const & params, bit_blaster_params const & bb_params):
         theory(m.mk_family_id("bv")),
         m_params(params),

src/smt/theory_bv.h

@@ -236,6 +236,7 @@ namespace smt {
         virtual void pop_scope_eh(unsigned num_scopes);
         virtual final_check_status final_check_eh();
         virtual void reset_eh();
+        virtual bool include_func_interp(func_decl* f);
         svector<theory_var>   m_merge_aux[2]; //!< auxiliary vector used in merge_zero_one_bits
         bool merge_zero_one_bits(theory_var r1, theory_var r2);
 

src/smt/theory_fpa.cpp

@@ -555,26 +555,11 @@ namespace smt {
         literal l(ctx.mk_bool_var(atom));
         ctx.set_var_theory(l.var(), get_id());
 
-        expr_ref bv_atom(m);
+        expr_ref bv_atom(convert_atom(atom));
-        bv_atom = convert_atom(atom);
+        expr_ref bv_atom_w_side_c(m);
-        SASSERT(is_app(bv_atom) && m.is_bool(bv_atom));
+        bv_atom_w_side_c = m.mk_and(bv_atom, mk_side_conditions());
-        bv_atom = m.mk_and(bv_atom, mk_side_conditions());
+        m_th_rw(bv_atom_w_side_c);
-
+        assert_cnstr(m.mk_eq(atom, bv_atom_w_side_c));
-        // CMW: Do not use assert_cnstr here; the internalizer expects normalized expressions.
-        // See GitHub issue #227
-        // assert_cnstr(m.mk_iff(atom, bv_atom));
-
-        ctx.internalize(atom, false);
-        ctx.internalize(bv_atom, false);
-        literal lit1(ctx.get_literal(atom));
-        literal lit2(ctx.get_literal(bv_atom));
-        ctx.mark_as_relevant(lit1);
-        ctx.mark_as_relevant(lit2);
-        literal lits1[2] = { lit1, ~lit2 };
-        literal lits2[2] = { ~lit1, lit2 };
-        ctx.mk_th_axiom(get_id(), 2, lits1);
-        ctx.mk_th_axiom(get_id(), 2, lits2);
-
         return true;
     }
 
@@ -752,10 +737,11 @@ namespace smt {
 
         expr_ref converted(m);
         converted = m.mk_and(convert(e), mk_side_conditions());
-        if (is_true)
+
-            assert_cnstr(m.mk_implies(e, converted));
+        expr_ref cnstr(m);
-        else
+        cnstr = (is_true) ? m.mk_implies(e, converted) : m.mk_implies(converted, e);
-            assert_cnstr(m.mk_implies(m.mk_not(e), m.mk_not(converted)));
+        m_th_rw(cnstr);
+        assert_cnstr(cnstr);
     }
 
     void theory_fpa::relevant_eh(app * n) {

src/tactic/fpa/fpa2bv_model_converter.cpp

@@ -45,6 +45,15 @@ void fpa2bv_model_converter::display(std::ostream & out) {
         unsigned indent = n.size() + 4;
         out << mk_ismt2_pp(it->m_value, m, indent) << ")";
     }
+    for (obj_map<func_decl, std::pair<app*, app*> >::iterator it = m_specials.begin();
+         it != m_specials.end();
+         it++) {
+        const symbol & n = it->m_key->get_name();
+        out << "\n  (" << n << " ";
+        unsigned indent = n.size() + 4;
+        out << mk_ismt2_pp(it->m_value.first, m, indent) << "; " <<
+               mk_ismt2_pp(it->m_value.second, m, indent) << ")";
+    }
     out << ")" << std::endl;
 }
 
@@ -79,12 +88,16 @@ model_converter * fpa2bv_model_converter::translate(ast_translation & translator
         translator.to().inc_ref(k);
         translator.to().inc_ref(v);
     }
-    for (obj_hashtable<func_decl>::iterator it = m_decls_to_hide.begin();
+    for (obj_map<func_decl, std::pair<app*, app*> >::iterator it = m_specials.begin();
-         it != m_decls_to_hide.end();
+         it != m_specials.end();
          it++) {
-        func_decl * k = translator(*it);
+        func_decl * k = translator(it->m_key);
-        res->m_decls_to_hide.insert(k);
+        app * v1 = translator(it->m_value.first);
+        app * v2 = translator(it->m_value.second);
+        res->m_specials.insert(k, std::pair<app*, app*>(v1, v2));
         translator.to().inc_ref(k);
+        translator.to().inc_ref(v1);
+        translator.to().inc_ref(v2);
     }
     return res;
 }
@@ -217,10 +230,34 @@ void fpa2bv_model_converter::convert(model * bv_mdl, model * float_mdl) {
 
     obj_hashtable<func_decl> seen;
 
-    for (obj_hashtable<func_decl>::iterator it = m_decls_to_hide.begin();
+    for (obj_map<func_decl, std::pair<app*, app*> >::iterator it = m_specials.begin();
-         it != m_decls_to_hide.end();
+         it != m_specials.end();
-         it++)
+         it++) {
-        seen.insert(*it);
+        func_decl * f = it->m_key;
+        expr_ref pzero(m), nzero(m);
+        pzero = fu.mk_pzero(f->get_range());
+        nzero = fu.mk_nzero(f->get_range());
+
+        expr_ref pn(m), np(m);
+        bv_mdl->eval(it->m_value.first, pn, true);
+        bv_mdl->eval(it->m_value.second, np, true);
+        seen.insert(it->m_value.first->get_decl());
+        seen.insert(it->m_value.second->get_decl());
+
+        rational pn_num, np_num;
+        unsigned bv_sz;
+        bu.is_numeral(pn, pn_num, bv_sz);
+        bu.is_numeral(np, np_num, bv_sz);
+
+        func_interp * flt_fi = alloc(func_interp, m, f->get_arity());
+        expr * pn_args[2] = { pzero, nzero };
+        if (pn != np) flt_fi->insert_new_entry(pn_args, (pn_num.is_one() ? nzero : pzero));
+        flt_fi->set_else(np_num.is_one() ? nzero : pzero);
+
+        float_mdl->register_decl(f, flt_fi);
+        TRACE("fpa2bv_mc", tout << "fp.min/fp.max special: " << std::endl <<
+                            mk_ismt2_pp(f, m) << " == " << mk_ismt2_pp(flt_fi->get_interp(), m) << std::endl;);
+    }
 
     for (obj_map<func_decl, expr*>::iterator it = m_const2bv.begin();
          it != m_const2bv.end();
@@ -362,10 +399,6 @@ void fpa2bv_model_converter::convert(model * bv_mdl, model * float_mdl) {
     }
 }
 
-model_converter * mk_fpa2bv_model_converter(ast_manager & m,
+model_converter * mk_fpa2bv_model_converter(ast_manager & m, fpa2bv_converter const & conv) {
-                                            obj_map<func_decl, expr*> const & const2bv,
+    return alloc(fpa2bv_model_converter, m, conv);
-                                            obj_map<func_decl, expr*> const & rm_const2bv,
-                                            obj_map<func_decl, func_decl*> const & uf2bvuf,
-                                            obj_hashtable<func_decl> const & decls_to_hide) {
-    return alloc(fpa2bv_model_converter, m, const2bv, rm_const2bv, uf2bvuf, decls_to_hide);
 }

src/tactic/fpa/fpa2bv_model_converter.h

@@ -27,44 +27,41 @@ class fpa2bv_model_converter : public model_converter {
     obj_map<func_decl, expr*>   m_const2bv;
     obj_map<func_decl, expr*>   m_rm_const2bv;
     obj_map<func_decl, func_decl*>  m_uf2bvuf;
-    obj_hashtable<func_decl>    m_decls_to_hide;
+    obj_map<func_decl, std::pair<app*, app*> > m_specials;
 
 public:
-    fpa2bv_model_converter(ast_manager & m, obj_map<func_decl, expr*> const & const2bv,
+    fpa2bv_model_converter(ast_manager & m, fpa2bv_converter const & conv) : m(m) {
-                           obj_map<func_decl, expr*> const & rm_const2bv,
+        for (obj_map<func_decl, expr*>::iterator it = conv.m_const2bv.begin();
-                           obj_map<func_decl, func_decl*> const & uf2bvuf,
+             it != conv.m_const2bv.end();
-                           obj_hashtable<func_decl> const & decls_to_hide) :
-                           m(m) {
-        for (obj_map<func_decl, expr*>::iterator it = const2bv.begin();
-             it != const2bv.end();
              it++)
         {
             m_const2bv.insert(it->m_key, it->m_value);
             m.inc_ref(it->m_key);
             m.inc_ref(it->m_value);
         }
-        for (obj_map<func_decl, expr*>::iterator it = rm_const2bv.begin();
+        for (obj_map<func_decl, expr*>::iterator it = conv.m_rm_const2bv.begin();
-             it != rm_const2bv.end();
+             it != conv.m_rm_const2bv.end();
              it++)
         {
             m_rm_const2bv.insert(it->m_key, it->m_value);
             m.inc_ref(it->m_key);
             m.inc_ref(it->m_value);
         }
-        for (obj_map<func_decl, func_decl*>::iterator it = uf2bvuf.begin();
+        for (obj_map<func_decl, func_decl*>::iterator it = conv.m_uf2bvuf.begin();
-             it != uf2bvuf.end();
+             it != conv.m_uf2bvuf.end();
              it++)
         {
             m_uf2bvuf.insert(it->m_key, it->m_value);
             m.inc_ref(it->m_key);
             m.inc_ref(it->m_value);
         }
-        for (obj_hashtable<func_decl>::iterator it = decls_to_hide.begin();
+        for (obj_map<func_decl, std::pair<app*, app*> >::iterator it = conv.m_specials.begin();
-             it != decls_to_hide.end();
+             it != conv.m_specials.end();
-             it++) 
+             it++) {
-        {
+            m_specials.insert(it->m_key, it->m_value);
-            m_decls_to_hide.insert(*it);
+            m.inc_ref(it->m_key);
-            m.inc_ref(*it);
+            m.inc_ref(it->m_value.first);
+            m.inc_ref(it->m_value.second);
         }
     }
 
@@ -72,7 +69,13 @@ public:
         dec_ref_map_key_values(m, m_const2bv);
         dec_ref_map_key_values(m, m_rm_const2bv);
         dec_ref_map_key_values(m, m_uf2bvuf);
-        dec_ref_collection_values(m, m_decls_to_hide);
+        for (obj_map<func_decl, std::pair<app*, app*> >::iterator it = m_specials.begin();
+             it != m_specials.end();
+             it++) {
+            m.dec_ref(it->m_key);
+            m.dec_ref(it->m_value.first);
+            m.dec_ref(it->m_value.second);
+        }
     }
 
     virtual void operator()(model_ref & md, unsigned goal_idx) {
@@ -92,7 +95,7 @@ public:
     virtual model_converter * translate(ast_translation & translator);
 
 protected:
-    fpa2bv_model_converter(ast_manager & m) : m(m) { }
+    fpa2bv_model_converter(ast_manager & m) : m(m){ }
 
     void convert(model * bv_mdl, model * float_mdl);
     expr_ref convert_bv2fp(sort * s, expr * sgn, expr * exp, expr * sig) const;
@@ -102,10 +105,6 @@ protected:
 };
 
 
-model_converter * mk_fpa2bv_model_converter(ast_manager & m,
+model_converter * mk_fpa2bv_model_converter(ast_manager & m, fpa2bv_converter const & conv);
-                                            obj_map<func_decl, expr*> const & const2bv,
-                                            obj_map<func_decl, expr*> const & rm_const2bv,
-                                            obj_map<func_decl, func_decl*> const & uf2bvuf,
-                                            obj_hashtable<func_decl> const & decls_to_hide);
 
 #endif

src/tactic/fpa/fpa2bv_tactic.cpp

@@ -105,7 +105,7 @@ class fpa2bv_tactic : public tactic {
             }
 
             if (g->models_enabled())
-                mc = mk_fpa2bv_model_converter(m, m_conv.const2bv(), m_conv.rm_const2bv(), m_conv.uf2bvuf(), m_conv.decls_to_hide());
+                mc = mk_fpa2bv_model_converter(m, m_conv);
 
             g->inc_depth();
             result.push_back(g.get());

src/tactic/smtlogics/qfaufbv_tactic.h

@@ -25,4 +25,8 @@ class tactic;
 
 tactic * mk_qfaufbv_tactic(ast_manager & m, params_ref const & p = params_ref());
 
+/*
+  ADD_TACTIC("qfaufbv",  "builtin strategy for solving QF_AUFBV problems.", "mk_qfaufbv_tactic(m, p)")
+*/
+
 #endif

src/tactic/smtlogics/qfauflia_tactic.h

@@ -25,4 +25,8 @@ class tactic;
 
 tactic * mk_qfauflia_tactic(ast_manager & m, params_ref const & p = params_ref());
 
+/*
+  ADD_TACTIC("qfauflia",  "builtin strategy for solving QF_AUFLIA problems.", "mk_qfauflia_tactic(m, p)")
+*/
+
 #endif

src/tactic/smtlogics/qfidl_tactic.h

@@ -25,4 +25,8 @@ class tactic;
 
 tactic * mk_qfidl_tactic(ast_manager & m, params_ref const & p = params_ref());
 
+/*
+    ADD_TACTIC("qfidl", "builtin strategy for solving QF_IDL problems.", "mk_qfidl_tactic(m, p)")
+*/
+
 #endif

src/tactic/smtlogics/qfuf_tactic.h

@@ -26,4 +26,8 @@ class tactic;
 
 tactic * mk_qfuf_tactic(ast_manager & m, params_ref const & p);
 
+/*
+  ADD_TACTIC("qfuf", "builtin strategy for solving QF_UF problems.", "mk_qfuf_tactic(m, p)")
+*/
+
 #endif

src/tactic/smtlogics/qfufbv_tactic.h

@@ -25,4 +25,8 @@ class tactic;
 
 tactic * mk_qfufbv_tactic(ast_manager & m, params_ref const & p = params_ref());
 
+/*
+  ADD_TACTIC("qfufbv", "builtin strategy for solving QF_UFBV problems.", "mk_qfufbv_tactic(m, p)")
+*/
+
 #endif