Merge branch 'master' into polysat

src/ast/rewriter/bv_rewriter.cpp

@@ -3019,8 +3019,8 @@ br_status bv_rewriter::mk_bvumul_no_overflow(unsigned num, expr * const * args,
 
 br_status bv_rewriter::mk_bvneg_overflow(expr * const arg, expr_ref & result) {
     unsigned int sz = get_bv_size(arg);
-    auto maxUnsigned = mk_numeral(rational::power_of_two(sz)-1, sz);
-    result = m.mk_eq(arg, maxUnsigned);
+    auto minSigned = mk_numeral(rational::power_of_two(sz - 1), sz);  // 0b1000...0
+    result = m.mk_eq(arg, minSigned);
     return BR_REWRITE3;
 }
 
@@ -3089,7 +3089,7 @@ br_status bv_rewriter::mk_bvssub_overflow(unsigned num, expr * const * args, exp
     SASSERT(num == 2);
     SASSERT(get_bv_size(args[0]) == get_bv_size(args[1]));
     auto sz = get_bv_size(args[0]);
-    auto minSigned = mk_numeral(-rational::power_of_two(sz-1), sz);
+    auto minSigned = mk_numeral(rational::power_of_two(sz-1), sz);
     expr_ref bvsaddo {m};
     expr * args2[2] = { args[0], m_util.mk_bv_neg(args[1]) };
     auto bvsaddo_stat = mk_bvsadd_overflow(2, args2, bvsaddo);
@@ -3102,7 +3102,7 @@ br_status bv_rewriter::mk_bvsdiv_overflow(unsigned num, expr * const * args, exp
     SASSERT(num == 2);
     SASSERT(get_bv_size(args[0]) == get_bv_size(args[1]));
     auto sz = get_bv_size(args[1]);
-    auto minSigned = mk_numeral(-rational::power_of_two(sz-1), sz);
+    auto minSigned = mk_numeral(rational::power_of_two(sz-1), sz);
     auto minusOne = mk_numeral(rational::power_of_two(sz) - 1, sz);
     result = m.mk_and(m.mk_eq(args[0], minSigned), m.mk_eq(args[1], minusOne));
     return BR_REWRITE_FULL;

src/ast/rewriter/der.cpp

@@ -176,9 +176,9 @@ void der::reduce1(quantifier * q, expr_ref & r, proof_ref & pr) {
     var * v = nullptr;
     expr_ref t(m);
 
-    if (is_forall(q) && is_var_diseq(e, num_decls, v, t) && !occurs(v, t))
+    if (is_forall(q) && is_var_diseq(e, num_decls, v, t) && !has_quantifiers(t) && !occurs(v, t))
         r = m.mk_false();
-    else if (is_exists(q) && is_var_eq(e, num_decls, v, t) && !occurs(v, t))
+    else if (is_exists(q) && is_var_eq(e, num_decls, v, t) && !has_quantifiers(t) && !occurs(v, t))
         r = m.mk_true();
     else {
         expr_ref_vector literals(m);

src/ast/rewriter/th_rewriter.cpp

@@ -74,6 +74,7 @@ struct th_rewriter_cfg : public default_rewriter_cfg {
     bool                m_push_ite_bv = true;
     bool                m_ignore_patterns_on_ground_qbody = true;
     bool                m_rewrite_patterns = true;
+    bool                m_enable_der = true;
 
 
     ast_manager & m() const { return m_b_rw.m(); }
@@ -89,6 +90,7 @@ struct th_rewriter_cfg : public default_rewriter_cfg {
         m_push_ite_bv    = p.push_ite_bv();
         m_ignore_patterns_on_ground_qbody = p.ignore_patterns_on_ground_qbody();
         m_rewrite_patterns = p.rewrite_patterns();
+        m_enable_der     = p.enable_der();
     }
 
     void updt_params(params_ref const & p) {
@@ -827,11 +829,12 @@ struct th_rewriter_cfg : public default_rewriter_cfg {
         expr_ref r(m());
 
         bool der_change = false;
-        if (is_quantifier(result) && to_quantifier(result)->get_num_patterns() == 0) {
+        if (m_enable_der && is_quantifier(result) && to_quantifier(result)->get_num_patterns() == 0) {
             m_der(to_quantifier(result), r, p2);
             der_change = result.get() != r.get();
             if (m().proofs_enabled() && der_change)
-                result_pr = m().mk_transitivity(result_pr, p2);            
+                result_pr = m().mk_transitivity(result_pr, p2);
+
             result = r;
         }
 

src/ast/simplifiers/bound_simplifier.cpp

@@ -58,9 +58,9 @@ struct bound_simplifier::rw : public rewriter_tpl<rw_cfg> {
 br_status bound_simplifier::reduce_app(func_decl* f, unsigned num_args, expr* const* args, expr_ref& result, proof_ref& pr) {
     rational N, hi, lo;
     if (a.is_mod(f) && num_args == 2 && a.is_numeral(args[1], N)) {
-        expr* x = args[0];
         auto& im = m_interval;
         scoped_dep_interval i(im);
+        expr* x = args[0];
         get_bounds(x, i);
         if (im.upper_is_inf(i) || im.lower_is_inf(i))
             return BR_FAILED;
@@ -83,7 +83,55 @@ br_status bound_simplifier::reduce_app(func_decl* f, unsigned num_args, expr* co
         }
         IF_VERBOSE(2, verbose_stream() << "potentially missed simplification: " << mk_pp(x, m) << " " << lo << " " << hi << " not reduced\n");
     }
-    return BR_FAILED;
+
+    expr_ref_buffer new_args(m);
+    expr_ref new_arg(m);
+    bool change = false;
+    for (unsigned i = 0; i < num_args; ++i) {
+        expr* arg = args[i];
+        change = reduce_arg(arg, new_arg) || change;
+        new_args.push_back(new_arg);
+    }
+    if (!change)
+        return BR_FAILED;
+
+    result = m.mk_app(f, num_args, new_args.data());
+
+    return BR_DONE;
+}
+
+bool bound_simplifier::reduce_arg(expr* arg, expr_ref& result) {
+    result = arg;
+    expr* x, *y;
+    rational N, lo, hi;
+    bool strict;
+    if ((a.is_le(arg, x, y) && a.is_numeral(y, N)) ||
+        (a.is_ge(arg, y, x) && a.is_numeral(y, N))) {
+
+        if (has_upper(x, hi, strict) && !strict && N >= hi) {
+            result = m.mk_true();
+            return true;
+        }
+        if (has_lower(x, lo, strict) && !strict && N < lo) {
+            result = m.mk_false();
+            return true;
+        }
+        return false;
+    }
+    
+    if ((a.is_le(arg, y, x) && a.is_numeral(y, N)) ||
+        (a.is_ge(arg, x, y) && a.is_numeral(y, N))) {
+        if (has_lower(x, lo, strict) && !strict && N <= lo) {
+            result = m.mk_true();
+            return true;
+        }
+        if (has_upper(x, hi, strict) && !strict && N > hi) {
+            result = m.mk_false();
+            return true;
+        }
+        return false;
+    }
+    return false;
 }
 
 void bound_simplifier::reduce() {

src/ast/simplifiers/bound_simplifier.h

@@ -77,8 +77,12 @@ class bound_simplifier : public dependent_expr_simplifier {
         return v;
     }
 
+    bool reduce_arg(expr* arg, expr_ref& result);
+
     br_status reduce_app(func_decl* f, unsigned num_args, expr* const* args, expr_ref& result, proof_ref& pr);
 
+    
+
     void assert_lower(expr* x, rational const& n, bool strict);
     void assert_upper(expr* x, rational const& n, bool strict);