Merge branch 'unstable' of https://git01.codeplex.com/z3 into fpa-api

Conflicts:
	scripts/mk_project.py

Signed-off-by: Christoph M. Wintersteiger <cwinter@microsoft.com>

src/ast/ast.cpp

@@ -640,6 +640,7 @@ basic_decl_plugin::basic_decl_plugin():
     m_iff_decl(0),
     m_xor_decl(0),
     m_not_decl(0),
+    m_interp_decl(0),
     m_implies_decl(0),
     
     m_proof_sort(0),
@@ -863,6 +864,7 @@ void basic_decl_plugin::set_manager(ast_manager * m, family_id id) {
     m_iff_decl     = mk_bool_op_decl("iff", OP_IFF, 2, false, true, false, false, true);
     m_xor_decl     = mk_bool_op_decl("xor", OP_XOR, 2, true, true);
     m_not_decl     = mk_bool_op_decl("not", OP_NOT, 1);
+    m_interp_decl  = mk_bool_op_decl("interp", OP_INTERP, 1);
     m_implies_decl = mk_implies_decl();
     
     m_proof_sort = m->mk_sort(symbol("Proof"), sort_info(id, PROOF_SORT));
@@ -887,6 +889,7 @@ void basic_decl_plugin::get_op_names(svector<builtin_name> & op_names, symbol co
     op_names.push_back(builtin_name("or", OP_OR));
     op_names.push_back(builtin_name("xor", OP_XOR));
     op_names.push_back(builtin_name("not", OP_NOT));
+    op_names.push_back(builtin_name("interp", OP_INTERP));
     op_names.push_back(builtin_name("=>", OP_IMPLIES));
     if (logic == symbol::null) {
         // user friendly aliases
@@ -898,6 +901,7 @@ void basic_decl_plugin::get_op_names(svector<builtin_name> & op_names, symbol co
         op_names.push_back(builtin_name("||", OP_OR));
         op_names.push_back(builtin_name("equals", OP_EQ));
         op_names.push_back(builtin_name("equiv", OP_IFF));
+        op_names.push_back(builtin_name("@@", OP_INTERP));
     }
 }
 
@@ -918,6 +922,7 @@ void basic_decl_plugin::finalize() {
     DEC_REF(m_and_decl);
     DEC_REF(m_or_decl);
     DEC_REF(m_not_decl);
+    DEC_REF(m_interp_decl);
     DEC_REF(m_iff_decl);
     DEC_REF(m_xor_decl);
     DEC_REF(m_implies_decl);
@@ -1016,6 +1021,7 @@ func_decl * basic_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters
     case OP_AND:     return m_and_decl;
     case OP_OR:      return m_or_decl;
     case OP_NOT:     return m_not_decl;
+    case OP_INTERP:  return m_interp_decl;
     case OP_IFF:     return m_iff_decl;
     case OP_IMPLIES: return m_implies_decl;
     case OP_XOR:     return m_xor_decl;
@@ -1051,6 +1057,7 @@ func_decl * basic_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters
     case OP_AND:     return m_and_decl;
     case OP_OR:      return m_or_decl;
     case OP_NOT:     return m_not_decl;
+    case OP_INTERP:  return m_interp_decl;
     case OP_IFF:     return m_iff_decl;
     case OP_IMPLIES: return m_implies_decl;
     case OP_XOR:     return m_xor_decl;
@@ -3146,4 +3153,11 @@ void scoped_mark::pop_scope(unsigned num_scopes) {
     }
 }
    
+// Added by KLM for use in GDB
+
+// show an expr_ref on stdout
+
+void prexpr(expr_ref &e){
+  std::cout << mk_pp(e.get(), e.get_manager()) << std::endl;
+}
 

src/ast/ast.h

@@ -1006,7 +1006,7 @@ enum basic_sort_kind {
 };
 
 enum basic_op_kind {
-    OP_TRUE, OP_FALSE, OP_EQ, OP_DISTINCT, OP_ITE, OP_AND, OP_OR, OP_IFF, OP_XOR, OP_NOT, OP_IMPLIES, OP_OEQ, LAST_BASIC_OP,
+    OP_TRUE, OP_FALSE, OP_EQ, OP_DISTINCT, OP_ITE, OP_AND, OP_OR, OP_IFF, OP_XOR, OP_NOT, OP_IMPLIES, OP_OEQ, OP_INTERP, LAST_BASIC_OP,
 
     PR_UNDEF, PR_TRUE, PR_ASSERTED, PR_GOAL, PR_MODUS_PONENS, PR_REFLEXIVITY, PR_SYMMETRY, PR_TRANSITIVITY, PR_TRANSITIVITY_STAR, PR_MONOTONICITY, PR_QUANT_INTRO,
     PR_DISTRIBUTIVITY, PR_AND_ELIM, PR_NOT_OR_ELIM, PR_REWRITE, PR_REWRITE_STAR, PR_PULL_QUANT, 
@@ -1028,6 +1028,7 @@ protected:
     func_decl * m_iff_decl;
     func_decl * m_xor_decl;
     func_decl * m_not_decl;
+    func_decl * m_interp_decl;
     func_decl * m_implies_decl;
     ptr_vector<func_decl> m_eq_decls;  // cached eqs
     ptr_vector<func_decl> m_ite_decls; // cached ites
@@ -2000,6 +2001,7 @@ public:
     app * mk_distinct_expanded(unsigned num_args, expr * const * args);
     app * mk_true() { return m_true; }
     app * mk_false() { return m_false; }
+    app * mk_interp(expr * arg) { return mk_app(m_basic_family_id, OP_INTERP, arg); }
 
     func_decl* mk_and_decl() { 
         sort* domain[2] = { m_bool_sort, m_bool_sort };

src/ast/datatype_decl_plugin.cpp

@@ -84,7 +84,8 @@ class datatype_decl {
     ptr_vector<constructor_decl> m_constructors;
 public:
     datatype_decl(const symbol & n, unsigned num_constructors, constructor_decl * const * constructors):
-        m_name(n), m_constructors(num_constructors, constructors) {}
+        m_name(n), m_constructors(num_constructors, constructors) {
+    }
     ~datatype_decl() {
         std::for_each(m_constructors.begin(), m_constructors.end(), delete_proc<constructor_decl>());
     }

src/ast/dl_decl_plugin.cpp

@@ -657,7 +657,9 @@ namespace datalog {
             SASSERT(value == 1);
             return m.mk_true();
         }
-        m.raise_exception("unrecognized sort");
+        std::stringstream strm;
+        strm << "sort '" << mk_pp(s, m) << "' is not recognized as a sort that contains numeric values.\nUse Bool, BitVec, Int, Real, or a Finite domain sort";
+        m.raise_exception(strm.str().c_str());
         return 0;
     }
 

src/ast/float_decl_plugin.cpp

@@ -85,6 +85,24 @@ bool float_decl_plugin::is_value(expr * n, mpf & val) {
         m_fm.set(val, m_values[to_app(n)->get_decl()->get_parameter(0).get_ext_id()]);
         return true;
     }
+    else if (is_app_of(n, m_family_id, OP_FLOAT_MINUS_INF)) {
+        unsigned ebits = to_app(n)->get_decl()->get_range()->get_parameter(0).get_int();
+        unsigned sbits = to_app(n)->get_decl()->get_range()->get_parameter(1).get_int();
+        m_fm.mk_ninf(ebits, sbits, val);
+        return true;
+    }
+    else if (is_app_of(n, m_family_id, OP_FLOAT_PLUS_INF)) {
+        unsigned ebits = to_app(n)->get_decl()->get_range()->get_parameter(0).get_int();
+        unsigned sbits = to_app(n)->get_decl()->get_range()->get_parameter(1).get_int();
+        m_fm.mk_pinf(ebits, sbits, val);
+        return true;
+    }
+    else if (is_app_of(n, m_family_id, OP_FLOAT_NAN)) {
+        unsigned ebits = to_app(n)->get_decl()->get_range()->get_parameter(0).get_int();
+        unsigned sbits = to_app(n)->get_decl()->get_range()->get_parameter(1).get_int();
+        m_fm.mk_nan(ebits, sbits, val);
+        return true;
+    }
     return false;
 }
 
@@ -457,6 +475,7 @@ void float_decl_plugin::get_op_names(svector<builtin_name> & op_names, symbol co
     op_names.push_back(builtin_name("plusInfinity",  OP_FLOAT_PLUS_INF));
     op_names.push_back(builtin_name("minusInfinity", OP_FLOAT_MINUS_INF));
     op_names.push_back(builtin_name("NaN", OP_FLOAT_NAN));
+
     op_names.push_back(builtin_name("roundNearestTiesToEven", OP_RM_NEAREST_TIES_TO_EVEN));
     op_names.push_back(builtin_name("roundNearestTiesToAway", OP_RM_NEAREST_TIES_TO_AWAY));
     op_names.push_back(builtin_name("roundTowardPositive", OP_RM_TOWARD_POSITIVE));
@@ -468,7 +487,7 @@ void float_decl_plugin::get_op_names(svector<builtin_name> & op_names, symbol co
     op_names.push_back(builtin_name("/", OP_FLOAT_DIV)); 
     op_names.push_back(builtin_name("*", OP_FLOAT_MUL)); 
 
-    op_names.push_back(builtin_name("abs", OP_FLOAT_ABS)); 
+    op_names.push_back(builtin_name("abs", OP_FLOAT_ABS));     
     op_names.push_back(builtin_name("remainder", OP_FLOAT_REM));  
     op_names.push_back(builtin_name("fusedMA", OP_FLOAT_FUSED_MA));  
     op_names.push_back(builtin_name("squareRoot", OP_FLOAT_SQRT));  
@@ -497,6 +516,49 @@ void float_decl_plugin::get_op_names(svector<builtin_name> & op_names, symbol co
 
     if (m_bv_plugin)
         op_names.push_back(builtin_name("asIEEEBV", OP_TO_IEEE_BV));
+
+    // We also support draft version 3
+    op_names.push_back(builtin_name("fp", OP_TO_FLOAT));
+
+    op_names.push_back(builtin_name("RNE", OP_RM_NEAREST_TIES_TO_EVEN));
+    op_names.push_back(builtin_name("RNA", OP_RM_NEAREST_TIES_TO_AWAY));
+    op_names.push_back(builtin_name("RTP", OP_RM_TOWARD_POSITIVE));
+    op_names.push_back(builtin_name("RTN", OP_RM_TOWARD_NEGATIVE));
+    op_names.push_back(builtin_name("RTZ", OP_RM_TOWARD_ZERO));
+
+    op_names.push_back(builtin_name("fp.abs", OP_FLOAT_ABS));
+    op_names.push_back(builtin_name("fp.neg", OP_FLOAT_UMINUS)); 
+    op_names.push_back(builtin_name("fp.add", OP_FLOAT_ADD)); 
+    op_names.push_back(builtin_name("fp.sub", OP_FLOAT_SUB));     
+    op_names.push_back(builtin_name("fp.mul", OP_FLOAT_MUL)); 
+    op_names.push_back(builtin_name("fp.div", OP_FLOAT_DIV));
+    op_names.push_back(builtin_name("fp.fma", OP_FLOAT_FUSED_MA)); 
+    op_names.push_back(builtin_name("fp.sqrt", OP_FLOAT_SQRT)); 
+    op_names.push_back(builtin_name("fp.rem", OP_FLOAT_REM));  
+    op_names.push_back(builtin_name("fp.eq", OP_FLOAT_EQ));    
+    op_names.push_back(builtin_name("fp.leq", OP_FLOAT_LE));
+    op_names.push_back(builtin_name("fp.lt",  OP_FLOAT_LT));    
+    op_names.push_back(builtin_name("fp.geq", OP_FLOAT_GE));
+    op_names.push_back(builtin_name("fp.gt",  OP_FLOAT_GT));
+    op_names.push_back(builtin_name("fp.isNormal", OP_FLOAT_IS_NORMAL));
+    op_names.push_back(builtin_name("fp.isSubnormal", OP_FLOAT_IS_SUBNORMAL));
+    op_names.push_back(builtin_name("fp.isZero", OP_FLOAT_IS_ZERO));
+    op_names.push_back(builtin_name("fp.isInfinite", OP_FLOAT_IS_INF));
+    op_names.push_back(builtin_name("fp.isNaN", OP_FLOAT_IS_NAN));
+    op_names.push_back(builtin_name("fp.min", OP_FLOAT_MIN));
+    op_names.push_back(builtin_name("fp.max", OP_FLOAT_MAX));
+    op_names.push_back(builtin_name("fp.convert", OP_TO_FLOAT));
+
+    if (m_bv_plugin) {
+    // op_names.push_back(builtin_name("fp.fromBv", OP_TO_FLOAT));
+    // op_names.push_back(builtin_name("fp.fromUBv", OP_TO_FLOAT));
+    // op_names.push_back(builtin_name("fp.fromSBv", OP_TO_FLOAT));
+    // op_names.push_back(builtin_name("fp.toUBv", OP_TO_IEEE_BV));
+    // op_names.push_back(builtin_name("fp.toSBv", OP_TO_IEEE_BV));
+    }
+    
+    op_names.push_back(builtin_name("fp.fromReal", OP_TO_FLOAT));
+    // op_names.push_back(builtin_name("fp.toReal", ?));
 }
 
 void float_decl_plugin::get_sort_names(svector<builtin_name> & sort_names, symbol const & logic) {
@@ -523,6 +585,9 @@ bool float_decl_plugin::is_value(app * e) const {
     case OP_RM_TOWARD_NEGATIVE:
     case OP_RM_TOWARD_ZERO:
     case OP_FLOAT_VALUE:
+    case OP_FLOAT_PLUS_INF:
+    case OP_FLOAT_MINUS_INF:
+    case OP_FLOAT_NAN:
         return true;
     case OP_TO_FLOAT:
         return m_manager->is_value(e->get_arg(0));

src/ast/rewriter/arith_rewriter.h

@@ -118,7 +118,7 @@ public:
 
     void mk_eq(expr * arg1, expr * arg2, expr_ref & result) {
         if (mk_eq_core(arg1, arg2, result) == BR_FAILED)
-            result = m_util.mk_le(arg1, arg2);
+            result = m_util.mk_eq(arg1, arg2);
     }
     void mk_le(expr * arg1, expr * arg2, expr_ref & result) {
         if (mk_le_core(arg1, arg2, result) == BR_FAILED)

src/ast/rewriter/ast_counter.cpp

@@ -108,6 +108,7 @@ void var_counter::count_vars(ast_manager & m, const app * pred, int coef) {
 unsigned var_counter::get_max_var(bool& has_var) {
     has_var = false;
     unsigned max_var = 0;
+    ptr_vector<quantifier> qs;
     while (!m_todo.empty()) {
         expr* e = m_todo.back();
         m_todo.pop_back();
@@ -117,14 +118,7 @@ unsigned var_counter::get_max_var(bool& has_var) {
         m_visited.mark(e, true);
         switch(e->get_kind()) {
         case AST_QUANTIFIER: {
-            var_counter aux_counter;
-            quantifier* q = to_quantifier(e);
-            bool has_var1 = false;
-            unsigned max_v = aux_counter.get_max_var(has_var1);
-            if (max_v > max_var + q->get_num_decls()) {
-                max_var = max_v - q->get_num_decls();
-                has_var = true;
-            }
+            qs.push_back(to_quantifier(e));
             break;                 
         }
         case AST_VAR: {
@@ -147,6 +141,20 @@ unsigned var_counter::get_max_var(bool& has_var) {
         }
     }
     m_visited.reset();
+
+    while (!qs.empty()) {
+        var_counter aux_counter;
+        quantifier* q = qs.back();
+        qs.pop_back();
+        aux_counter.m_todo.push_back(q->get_expr());
+        bool has_var1 = false;
+        unsigned max_v = aux_counter.get_max_var(has_var1);
+        if (max_v >= max_var + q->get_num_decls()) {
+            max_var = max_v - q->get_num_decls();
+            has_var = has_var || has_var1;                
+        }
+    }
+
     return max_var;
 }
 

src/ast/rewriter/float_rewriter.cpp

@@ -354,7 +354,7 @@ br_status float_rewriter::mk_lt(expr * arg1, expr * arg2, expr_ref & result) {
     if (m_util.is_minus_inf(arg1)) {
         // -oo < arg2 -->  not(arg2 = -oo) and not(arg2 = NaN)
         result = m().mk_and(m().mk_not(m().mk_eq(arg2, arg1)), mk_neq_nan(arg2));
-        return BR_REWRITE2;
+        return BR_REWRITE3;
     }
     if (m_util.is_minus_inf(arg2)) {
         // arg1 < -oo  --> false
@@ -369,7 +369,7 @@ br_status float_rewriter::mk_lt(expr * arg1, expr * arg2, expr_ref & result) {
     if (m_util.is_plus_inf(arg2)) {
         // arg1 < +oo --> not(arg1 = +oo) and not(arg1 = NaN)
         result = m().mk_and(m().mk_not(m().mk_eq(arg1, arg2)), mk_neq_nan(arg1));
-        return BR_REWRITE2;
+        return BR_REWRITE3;
     }
 
     scoped_mpf v1(m_util.fm()), v2(m_util.fm());
@@ -490,7 +490,11 @@ br_status float_rewriter::mk_is_sign_minus(expr * arg1, expr_ref & result) {
 br_status float_rewriter::mk_eq_core(expr * arg1, expr * arg2, expr_ref & result) {
     scoped_mpf v1(m_util.fm()), v2(m_util.fm());
     if (m_util.is_value(arg1, v1) && m_util.is_value(arg2, v2)) {
-        result = (v1 == v2) ? m().mk_true() : m().mk_false();
+        // Note: == is the floats-equality, here we need normal equality.
+        result = (m_fm.is_nan(v1) && m_fm.is_nan(v2)) ? m().mk_true() :
+                 (m_fm.is_zero(v1) && m_fm.is_zero(v2) && m_fm.sgn(v1)!=m_fm.sgn(v2)) ? m().mk_false() :
+                 (v1 == v2) ? m().mk_true() :
+                 m().mk_false();
         return BR_DONE;
     }
 

src/ast/scoped_proof.h

@@ -0,0 +1,55 @@
+/*++
+Copyright (c) 2013 Microsoft Corporation
+
+Module Name:
+
+    scoped_proof.h
+
+Abstract:
+
+    Scoped proof environments. Toggles enabling proofs.
+
+Author:
+
+    Nikolaj Bjorner (nbjorner) 2013-08-28
+
+Revision History:
+
+--*/
+#ifndef _SCOPED_PROOF__H_
+#define _SCOPED_PROOF_H_
+
+#include "ast.h"
+
+class scoped_proof_mode {
+    ast_manager&   m;
+    proof_gen_mode m_mode;
+public:
+    scoped_proof_mode(ast_manager& m, proof_gen_mode mode): m(m) {
+        m_mode = m.proof_mode();
+        m.toggle_proof_mode(mode);
+    }
+    ~scoped_proof_mode() {
+            m.toggle_proof_mode(m_mode);            
+        }
+    
+};
+
+class scoped_proof : public scoped_proof_mode {
+public:
+    scoped_proof(ast_manager& m): scoped_proof_mode(m, PGM_FINE) {}
+};
+
+class scoped_no_proof : public scoped_proof_mode {
+public:
+    scoped_no_proof(ast_manager& m): scoped_proof_mode(m, PGM_DISABLED) {}
+};
+
+class scoped_restore_proof : public scoped_proof_mode {
+public:
+    scoped_restore_proof(ast_manager& m): scoped_proof_mode(m, m.proof_mode()) {}
+};
+
+
+
+#endif

src/ast/simplifier/array_simplifier_plugin.cpp

@@ -68,7 +68,7 @@ bool array_simplifier_plugin::reduce(func_decl * f, unsigned num_args, expr * co
     set_reduce_invoked();
     if (m_presimp)
         return false;
-#if _DEBUG
+#if Z3DEBUG
     for (unsigned i = 0; i < num_args && i < f->get_arity(); ++i) {
         SASSERT(m_manager.get_sort(args[i]) == f->get_domain(i));
     }

src/ast/simplifier/bv_simplifier_plugin.cpp

@@ -179,7 +179,7 @@ bool bv_simplifier_plugin::reduce(func_decl * f, unsigned num_args, expr * const
     }
     SASSERT(result.get());
 
-    TRACE("bv_simplifier",
+    TRACE("bv_simplifier", 
           tout << mk_pp(f, m_manager) << "\n";
           for (unsigned i = 0; i < num_args; ++i) {
               tout << mk_pp(args[i], m_manager) << " ";