Add new tactic bound-simplifier for integer-based bit-vector reasoning.

RELEASE_NOTES.md

@@ -14,6 +14,11 @@ Version 4.next
 Version 4.12.2
 ==============
 - remove MSF (Microsoft Solver Foundation) plugin
+- add bound_simplifier tactic.
+  It eliminates occurrences of "mod" operators when bounds information
+  implies that the modulus is redundant. This tactic is useful for
+  benchmarks created by converting bit-vector semantics to integer 
+  reasoning.
 
 Version 4.12.1
 ==============

src/ast/simplifiers/CMakeLists.txt

@@ -2,6 +2,8 @@ z3_add_component(simplifiers
   SOURCES
     bit_blaster.cpp
     bound_manager.cpp
+    bound_propagator.cpp
+    bound_simplifier.cpp
     bv_slice.cpp
     card2bv.cpp
     demodulator_simplifier.cpp
@@ -11,6 +13,7 @@ z3_add_component(simplifiers
     eliminate_predicates.cpp
     euf_completion.cpp
     extract_eqs.cpp
+    linear_equation.cpp
     max_bv_sharing.cpp
     model_reconstruction_trail.cpp
     propagate_values.cpp

src/ast/simplifiers/bound_propagator.cpp

@@ -17,7 +17,7 @@ Author:
 Revision History:
 
 --*/
-#include "tactic/arith/bound_propagator.h"
+#include "ast/simplifiers/bound_propagator.h"
 #include<cmath>
 
 // -------------------------------

src/ast/simplifiers/bound_propagator.h

@@ -24,7 +24,7 @@ Revision History:
 #include "util/params.h"
 #include "util/statistics.h"
 #include "util/numeral_buffer.h"
-#include "tactic/arith/linear_equation.h"
+#include "ast/simplifiers/linear_equation.h"
 
 class bound_propagator {
 public:

src/ast/simplifiers/bound_simplifier.cpp

@@ -0,0 +1,306 @@
+/*++
+Copyright (c) 2022 Microsoft Corporation
+
+Module Name:
+
+    bounds_simplifier.cpp
+
+Author:
+
+    Nikolaj Bjorner (nbjorner) 2023-01-22
+
+--*/
+
+
+#include "ast/ast_pp.h"
+#include "ast/simplifiers/bound_simplifier.h"
+#include "ast/rewriter/rewriter_def.h"
+
+struct bound_simplifier::rw_cfg : public default_rewriter_cfg {
+    ast_manager& m;
+    bound_propagator& bp;
+    bound_simplifier& s;
+    arith_util a;
+    rw_cfg(bound_simplifier& s):m(s.m), bp(s.bp), s(s), a(m) {}
+
+    br_status reduce_app(func_decl* f, unsigned num_args, expr * const* args, expr_ref& result, proof_ref& pr) {
+        rational N, hi, lo;
+        bool strict;
+        if (a.is_mod(f) && num_args == 2 && a.is_numeral(args[1], N)) {
+            expr* x = args[0];
+            if (!s.has_upper(x, hi, strict) || strict)
+                return BR_FAILED;
+            if (!s.has_lower(x, lo, strict) || strict)
+                return BR_FAILED;
+            if (hi - lo >= N)
+                return BR_FAILED;
+            if (N > hi && lo >= 0) {
+                result = x;
+                return BR_DONE;
+            }
+            if (2*N > hi && lo >= N) {
+                result = a.mk_sub(x, a.mk_int(N));
+                s.m_rewriter(result);
+                return BR_DONE;
+            }
+            IF_VERBOSE(2, verbose_stream() << "potentially missed simplification: " << mk_pp(x, m) << " " << lo << " " << hi << " not reduced\n");
+        }
+        return BR_FAILED;
+    }
+};  
+
+struct bound_simplifier::rw : public rewriter_tpl<rw_cfg> {
+    rw_cfg m_cfg;
+
+    rw(bound_simplifier& s):
+        rewriter_tpl<rw_cfg>(s.m, false, m_cfg),
+        m_cfg(s) {
+    }
+};    
+
+void bound_simplifier::reduce() {
+    
+    m_updated = true;
+    for (unsigned i = 0; i < 5 && m_updated; ++i) {
+        m_updated = false;
+        reset();
+        for (unsigned idx : indices()) 
+            insert_bound(m_fmls[idx]);
+        for (unsigned idx : indices()) 
+            tighten_bound(m_fmls[idx]);
+        
+        rw rw(*this);
+
+        // TODO: take over propagate_ineq:
+        // bp.propagate();
+        // serialize bounds
+        
+        proof_ref pr(m);
+        expr_ref r(m);
+        for (unsigned idx : indices()) {
+            auto const& d = m_fmls[idx];
+            rw(d.fml(), r, pr);
+            if (r != d.fml()) {
+                m_fmls.update(idx, dependent_expr(m, r, mp(d.pr(), pr), d.dep()));
+                m_updated = true;
+            }
+        }
+    }
+}
+
+// generalization to summations?
+
+bool bound_simplifier::is_offset(expr* e, expr* x, rational& n) {
+    expr* y, *z;
+    if (a.is_add(e, y, z)) {
+        if (x != y)
+            std::swap(y, z);
+        return x == y && a.is_numeral(z, n);
+    }
+    return false;
+}
+
+bool bound_simplifier::insert_bound(dependent_expr const& de) {
+    if (de.pr())
+        return false;
+    if (de.dep())
+        return false;
+    rational n, n0;
+    expr* x, *y, *f = de.fml();
+
+    if (m.is_eq(f, x, y)) {
+        if (a.is_numeral(y))
+            std::swap(x, y);
+        if (a.is_numeral(x, n)) {
+            assert_lower(y, n, false);
+            assert_upper(y, n, false);
+            return true;
+        }
+    }
+    else if (a.is_le(f, x, y)) {
+        if (a.is_numeral(x, n)) 
+            assert_lower(y, n, false);
+        else if (a.is_numeral(y, n))
+            assert_upper(x, n, false);
+        else 
+            return false;
+        return true;
+    }
+    else if (a.is_ge(f, x, y)) {
+        if (a.is_numeral(x, n))
+            assert_upper(y, n, false);
+        else if (a.is_numeral(y, n))
+            assert_lower(x, n, false);
+        else 
+            return false;
+        return true;
+    }
+    else if (m.is_not(f, f)) {
+        if (a.is_le(f, x, y)) {
+            if (a.is_numeral(x, n)) 
+                assert_upper(y, n, true);
+            else if (a.is_numeral(y, n))
+                assert_lower(x, n, true);
+            else
+                return false;
+            return true;
+        }
+        else if (a.is_ge(f, x, y)) {
+            if (a.is_numeral(x, n))
+                assert_lower(y, n, true);
+            else if (a.is_numeral(y, n))
+                assert_upper(x, n, true);
+            else 
+                return false;
+            return true;
+        }
+    }
+    return false;
+}
+
+void bound_simplifier::tighten_bound(dependent_expr const& de) {
+    if (de.pr())
+        return;
+    if (de.dep())
+        return;
+    rational n, k;
+    expr* x, *y, *f = de.fml();
+    expr* z, *u;
+    bool strict;
+    if (a.is_le(f, x, y)) {
+        // x <= (x + k) mod N && x >= 0 -> x + k < N
+        if (a.is_mod(y, z, u) && a.is_numeral(u, n) && has_lower(x, k, strict) && k >= 0 && is_offset(z, x, k) && k > 0 && k < n) {
+            assert_upper(x, n - k, true);
+        }
+    }
+    if (m.is_not(f, f) && m.is_eq(f, x, y)) {
+        if (a.is_numeral(x))
+            std::swap(x, y);
+        bool strict;
+        if (a.is_numeral(y, n)) {
+            if (has_lower(x, k, strict) && !strict && k == n) 
+                assert_lower(x, k, true);
+            else if (has_upper(x, k, strict) && !strict && k == n) 
+                assert_upper(x, k, true);
+        }
+    }
+}
+
+void bound_simplifier::assert_upper(expr* x, rational const& n, bool strict) {
+    scoped_mpq c(nm);
+    nm.set(c, n.to_mpq());    
+    bp.assert_upper(to_var(x), c, strict);
+}
+
+
+void bound_simplifier::assert_lower(expr* x, rational const& n, bool strict) {
+    scoped_mpq c(nm);
+    nm.set(c, n.to_mpq());
+    bp.assert_lower(to_var(x), c, strict);
+}
+
+//
+// TODO: Use math/interval/interval.h
+//
+
+bool bound_simplifier::has_lower(expr* x, rational& n, bool& strict) {
+    if (is_var(x)) {
+        unsigned v = to_var(x);
+        if (bp.has_lower(v)) { 
+            mpq const & q = bp.lower(v, strict);
+            n = rational(q);
+            return true;
+        }
+    }
+    if (a.is_numeral(x, n)) {
+        strict = false;
+        return true;
+    }
+    if (a.is_mod(x)) {
+        n = rational::zero();
+        strict = false;
+        return true;
+    }
+    expr* y, *z;
+    if (a.is_idiv(x, y, z) && has_lower(z, n, strict) && n > 0 && has_lower(y, n, strict))
+        return true;
+
+    if (a.is_add(x)) {
+        rational bound;
+        strict = false;
+        n = 0;
+        bool is_strict;
+        for (expr* arg : *to_app(x)) {
+            if (!has_lower(arg, bound, is_strict))
+                return false;
+            strict |= is_strict;
+            n += bound;
+        }
+        return true;
+    }
+
+    if (a.is_mul(x, y, z)) {
+        // TODO: this is done generally using math/interval/interval.h
+        rational bound1, bound2;
+        bool strict1, strict2;
+        if (has_lower(y, bound1, strict1) && !strict1 &&
+            has_lower(z, bound1, strict2) && !strict2 &&
+            bound1 >= 0 && bound2 >= 0) {
+            n = bound1*bound2;
+            strict = false;
+            return true;
+        }
+    }
+
+    return false;
+}
+
+
+bool bound_simplifier::has_upper(expr* x, rational& n, bool& strict) {
+    if (is_var(x)) {
+        unsigned v = to_var(x);
+        if (bp.has_upper(v)) { 
+            mpq const & q = bp.upper(v, strict);
+            n = rational(q);
+            return true;
+        }
+    }
+
+    // perform light-weight abstract analysis
+    // y * (u / y) is bounded by u, if y > 0
+
+    if (a.is_numeral(x, n)) {
+        strict = false;
+        return true;
+    }
+
+    if (a.is_add(x)) {
+        rational bound;
+        strict = false;
+        n = 0;
+        bool is_strict;
+        for (expr* arg : *to_app(x)) {
+            if (!has_upper(arg, bound, is_strict))
+                return false;
+            strict |= is_strict;
+            n += bound;
+        }
+        return true;
+    }
+
+    expr* y, *z, *u, *v;
+    if (a.is_mul(x, y, z) && a.is_idiv(z, u, v) && v == y && has_lower(y, n, strict) && n > 0 && has_upper(u, n, strict))
+        return true;
+    if (a.is_idiv(x, y, z) && has_lower(z, n, strict) && n > 0 && has_upper(y, n, strict))
+        return true;
+
+    return false;
+}
+
+
+void bound_simplifier::reset() {
+    bp.reset();
+    m_var2expr.reset();
+    m_expr2var.reset();
+    m_num_vars = 0;
+}

src/ast/simplifiers/bound_simplifier.h

@@ -0,0 +1,90 @@
+/*++
+Copyright (c) 2022 Microsoft Corporation
+
+Module Name:
+
+    bound_simplifier.h
+
+Author:
+
+    Nikolaj Bjorner (nbjorner) 2023-01-22
+
+Description:
+
+    Collects bounds of sub-expressions and uses them to simplify modulus
+    expressions. 
+    propagate_ineqs_tactic handles other propagations with bounds.
+
+--*/
+
+#pragma once
+
+#include "ast/arith_decl_plugin.h"
+#include "ast/rewriter/th_rewriter.h"
+#include "ast/simplifiers/dependent_expr_state.h"
+#include "ast/simplifiers/bound_propagator.h"
+
+
+class bound_simplifier : public dependent_expr_simplifier {
+    arith_util              a;
+    th_rewriter             m_rewriter;
+    unsynch_mpq_manager     nm;
+    small_object_allocator  m_alloc;
+    bound_propagator        bp;
+    unsigned                m_num_vars = 0;
+    ptr_vector<expr>        m_var2expr;
+    unsigned_vector         m_expr2var;
+    bool                    m_updated = false;
+
+    struct rw_cfg;
+    struct rw;
+   
+    bool insert_bound(dependent_expr const& de);
+    void tighten_bound(dependent_expr const& de);
+
+    void reset();
+
+    expr* to_expr(unsigned v) const { 
+        return m_var2expr.get(v, nullptr); 
+    }
+
+    bool is_var(expr* e) const {
+        return UINT_MAX != m_expr2var.get(e->get_id(), UINT_MAX);
+    }
+
+    unsigned to_var(expr* e) { 
+        unsigned v = m_expr2var.get(e->get_id(), UINT_MAX); 
+        if (v == UINT_MAX) {
+            v = m_num_vars++;
+            bp.mk_var(v, a.is_int(e));
+            m_expr2var.setx(e->get_id(), v, UINT_MAX);
+            m_var2expr.setx(v, e, nullptr);
+        }
+        return v;
+    }
+
+    void assert_lower(expr* x, rational const& n, bool strict);
+    void assert_upper(expr* x, rational const& n, bool strict);
+
+    bool has_upper(expr* x, rational& n, bool& strict);
+    bool has_lower(expr* x, rational& n, bool& strict);
+
+    // e = x + offset
+    bool is_offset(expr* e, expr* x, rational& offset);
+
+public:
+
+    bound_simplifier(ast_manager& m, params_ref const& p, dependent_expr_state& fmls):
+        dependent_expr_simplifier(m, fmls),
+        a(m),
+        m_rewriter(m),
+        bp(nm, m_alloc, p) {
+    }
+
+    char const* name() const override { return "bounds-simplifier"; }
+      
+    bool supports_proofs() const override { return false; }
+
+    void reduce() override;
+};
+

src/ast/simplifiers/extract_eqs.cpp

@@ -88,10 +88,13 @@ namespace euf {
         expr_ref_vector    m_args, m_trail;
         expr_sparse_mark   m_nonzero;
         bool               m_enabled = true;
+        bool               m_eliminate_mod = true;
 
 
         // solve u mod r1 = y -> u = r1*mod!1 + y
         void solve_mod(expr* orig, expr* x, expr* y, expr_dependency* d, dep_eq_vector& eqs) {
+            if (!m_eliminate_mod)
+                return;
             expr* u, * z;
             rational r1, r2;
             if (!a.is_mod(x, u, z))
@@ -296,13 +299,12 @@ break;
                 add_pos(f);
                 m_bm(f, d, p);
             }
-
         }
 
-
         void updt_params(params_ref const& p) override {
             tactic_params tp(p);
             m_enabled = p.get_bool("theory_solver", tp.solve_eqs_ite_solver());
+            m_eliminate_mod = p.get_bool("eliminate_mod", true);
         }
     };
 

src/ast/simplifiers/linear_equation.cpp

@@ -18,7 +18,7 @@ Author:
 Revision History:
 
 --*/
-#include "tactic/arith/linear_equation.h"
+#include "ast/simplifiers/linear_equation.h"
 
 /**
    \brief Return the position of variable x_i in the linear equation.

src/ast/simplifiers/solve_eqs.cpp

@@ -294,6 +294,7 @@ namespace euf {
         r.insert("theory_solver", CPK_BOOL, "theory solvers.", "true");
         r.insert("ite_solver", CPK_BOOL, "use if-then-else solver.", "true");
         r.insert("context_solve", CPK_BOOL, "solve equalities under disjunctions.", "false");
+        r.insert("eliminate_mod", CPK_BOOL, "eliminate modulus from equations", "true");
     }
 
     void solve_eqs::collect_statistics(statistics& st) const {

src/tactic/arith/CMakeLists.txt

@@ -2,7 +2,6 @@ z3_add_component(arith_tactics
   SOURCES
     add_bounds_tactic.cpp
     arith_bounds_tactic.cpp
-    bound_propagator.cpp
     bv2int_rewriter.cpp
     bv2real_rewriter.cpp
     degree_shift_tactic.cpp
@@ -13,7 +12,6 @@ z3_add_component(arith_tactics
     fm_tactic.cpp
     lia2card_tactic.cpp
     lia2pb_tactic.cpp
-    linear_equation.cpp
     nla2bv_tactic.cpp
     normalize_bounds_tactic.cpp
     pb2bv_model_converter.cpp
@@ -27,6 +25,7 @@ z3_add_component(arith_tactics
     sat
   TACTIC_HEADERS
     add_bounds_tactic.h
+    bound_simplifier_tactic.h
     card2bv_tactic.h
     degree_shift_tactic.h
     diff_neq_tactic.h

src/tactic/arith/bound_simplifier_tactic.h

@@ -0,0 +1,41 @@
+/*++
+Copyright (c) 2023 Microsoft Corporation
+
+Module Name:
+
+    bound_simplifier_tactic.h
+
+Author:
+
+    Nikolaj Bjorner (nbjorner) 2023-01-22
+
+Tactic Documentation:
+
+## Tactic bound-simplifier
+
+### Short Description
+
+Tactic for simplifying arithmetical expressions modulo bounds
+
+### Long Description
+
+The tactic is used to eliminate occurrences of modulus expressions when it is known that terms are within the bounds
+of the modulus.
+
+
+--*/
+#pragma once
+
+#include "util/params.h"
+#include "tactic/tactic.h"
+#include "tactic/dependent_expr_state_tactic.h"
+#include "ast/simplifiers/bound_simplifier.h"
+
+inline tactic* mk_bound_simplifier_tactic(ast_manager& m, params_ref const& p = params_ref()) {
+    return alloc(dependent_expr_state_tactic, m, p,
+                 [](auto& m, auto& p, auto &s) -> dependent_expr_simplifier* { return alloc(bound_simplifier, m, p, s); });
+}
+
+/*
+  ADD_TACTIC("bound-simplifier", "Simplify arithmetical expressions modulo bounds.", "mk_bound_simplifier_tactic(m, p)")
+*/

src/tactic/arith/card2bv_tactic.h

@@ -3,7 +3,7 @@ Copyright (c) 2014 Microsoft Corporation
 
 Module Name:
 
-    card2bv_tactic.cpp
+    card2bv_tactic.h
 
 Author:
 

src/tactic/arith/propagate_ineqs_tactic.cpp

@@ -31,7 +31,7 @@ Notes:
 
 --*/
 #include "tactic/tactical.h"
-#include "tactic/arith/bound_propagator.h"
+#include "ast/simplifiers/bound_propagator.h"
 #include "ast/arith_decl_plugin.h"
 #include "tactic/core/simplify_tactic.h"
 #include "ast/ast_smt2_pp.h"
@@ -221,9 +221,9 @@ struct propagate_ineqs_tactic::imp {
               strict = true;
             }
         }
-         else {
+        else 
-          return false;
+            return false;
-        }
+
         expr * lhs = to_app(t)->get_arg(0);
         expr * rhs = to_app(t)->get_arg(1);
         expr* a, *b;
@@ -251,6 +251,7 @@ struct propagate_ineqs_tactic::imp {
         a_var x = mk_linear_pol(lhs);
         mpq c_prime;
         nm.set(c_prime, c.to_mpq());
+        verbose_stream() << mk_ismt2_pp(t, m) << " bound " << c << "\n";
         if (k == EQ) {
             SASSERT(!strict);
             bp.assert_lower(x, c_prime, false);