improvements to arithmetic preprocessing simplificaiton and axiom generation for #1683

Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com>

src/ast/rewriter/arith_rewriter.cpp

@@ -800,52 +800,105 @@ br_status arith_rewriter::mk_idiv_core(expr * arg1, expr * arg2, expr_ref & resu
         result = m_util.mk_numeral(div(v1, v2), is_int);
         return BR_DONE;
     }
-    expr_ref quot(m());
-    if (divides(arg1, arg2, quot)) {
-        result = m_util.mk_mul(quot, m_util.mk_idiv(arg1, arg1));
-        return BR_REWRITE2;
+    if (m_util.is_numeral(arg2, v2, is_int) && v2.is_one()) {
+        result = arg1;
+        return BR_DONE;
+    }
+    if (m_util.is_numeral(arg2, v2, is_int) && v2.is_zero()) {
+        return BR_FAILED;
+    }
+    if (arg1 == arg2) {
+        expr_ref zero(m_util.mk_int(0), m());
+        result = m().mk_ite(m().mk_eq(arg1, zero), m_util.mk_idiv(zero, zero), m_util.mk_int(1));
+        return BR_REWRITE3;
+    }
+    if (divides(arg1, arg2, result)) {
+        return BR_REWRITE_FULL;
     }
     return BR_FAILED;
 }
 
-bool arith_rewriter::divides(expr* d, expr* n, expr_ref& quot) {
-    if (d == n) {
-        quot = m_util.mk_numeral(rational(1), m_util.is_int(d));
+
+// 
+// implement div ab ac = floor( ab / ac) = floor (b / c) = div b c
+//
+bool arith_rewriter::divides(expr* num, expr* den, expr_ref& result) {
+    expr_fast_mark1 mark;
+    rational num_r(1), den_r(1);
+    expr* num_e = nullptr, *den_e = nullptr;
+    ptr_buffer<expr> args1, args2;
+    flat_mul(num, args1);
+    flat_mul(den, args2);
+    for (expr * arg : args1) {
+        mark.mark(arg);
+        if (m_util.is_numeral(arg, num_r)) num_e = arg;
+    }
+    for (expr* arg : args2) {
+        if (mark.is_marked(arg)) {
+            result = remove_divisor(arg, num, den);
+            return true;
+        }
+        if (m_util.is_numeral(arg, den_r)) den_e = arg;
+    }
+    rational g = gcd(num_r, den_r);
+    if (!g.is_one()) {
+        SASSERT(g.is_pos());
+        // replace num_e, den_e by their gcd reduction.
+        for (unsigned i = 0; i < args1.size(); ++i) {
+            if (args1[i] == num_e) {
+                args1[i] = m_util.mk_numeral(num_r / g, true);
+                break;
+            }
+        }
+        for (unsigned i = 0; i < args2.size(); ++i) {
+            if (args2[i] == den_e) {
+                args2[i] = m_util.mk_numeral(den_r / g, true);
+                break;
+            }
+        }
+        
+        num = m_util.mk_mul(args1.size(), args1.c_ptr());
+        den = m_util.mk_mul(args2.size(), args2.c_ptr());
+        result = m_util.mk_idiv(num, den);
         return true;
     }
-    if (m_util.is_mul(n)) {
-        expr_ref_vector muls(m());
-        muls.push_back(n);
-        expr* n1, *n2;
-        rational r1, r2;
-        for (unsigned i = 0; i < muls.size(); ++i) {
-            if (m_util.is_mul(muls[i].get(), n1, n2)) {
-                muls[i] = n1;
-                muls.push_back(n2);
-                --i;
-            }
-        }
-        if (m_util.is_numeral(d, r1) && !r1.is_zero()) {
-            for (unsigned i = 0; i < muls.size(); ++i) {
-                if (m_util.is_numeral(muls[i].get(), r2) && (r2 / r1).is_int()) {
-                    muls[i] = m_util.mk_numeral(r2 / r1, m_util.is_int(d));
-                    quot = m_util.mk_mul(muls.size(), muls.c_ptr());
-                    return true;
-                }            
-            }
-        }
-        else {
-            for (unsigned i = 0; i < muls.size(); ++i) {
-                if (d == muls[i].get()) {
-                    muls[i] = muls.back();
-                    muls.pop_back();
-                    quot = m_util.mk_mul(muls.size(), muls.c_ptr());
-                    return true;
-                }            
-            }
+    return false;
+}
+
+expr_ref arith_rewriter::remove_divisor(expr* arg, expr* num, expr* den) {
+    ptr_buffer<expr> args1, args2;
+    flat_mul(num, args1);
+    flat_mul(den, args2);
+    remove_divisor(arg, args1);
+    remove_divisor(arg, args2);
+    expr_ref zero(m_util.mk_int(0), m());
+    num = args1.empty() ? m_util.mk_int(1) : m_util.mk_mul(args1.size(), args1.c_ptr());
+    den = args2.empty() ? m_util.mk_int(1) : m_util.mk_mul(args2.size(), args2.c_ptr());
+    return expr_ref(m().mk_ite(m().mk_eq(zero, arg), m_util.mk_idiv(zero, zero), m_util.mk_idiv(num, den)), m());
+}
+
+void arith_rewriter::flat_mul(expr* e, ptr_buffer<expr>& args) {
+    args.push_back(e);
+    for (unsigned i = 0; i < args.size(); ++i) {
+        e = args[i];
+        if (m_util.is_mul(e)) {
+            args.append(to_app(e)->get_num_args(), to_app(e)->get_args());
+            args[i] = args.back();
+            args.shrink(args.size()-1);
+            --i;
+        }                
+    }
+}
+
+void arith_rewriter::remove_divisor(expr* d, ptr_buffer<expr>& args) {
+    for (unsigned i = 0; i < args.size(); ++i) {
+        if (args[i] == d) {
+            args[i] = args.back();
+            args.shrink(args.size()-1);
+            return;
         }
     }
-    return false;
+    UNREACHABLE();
 }
 
 br_status arith_rewriter::mk_mod_core(expr * arg1, expr * arg2, expr_ref & result) {

src/ast/rewriter/arith_rewriter.h

@@ -95,7 +95,10 @@ class arith_rewriter : public poly_rewriter<arith_rewriter_core> {
     expr_ref neg_monomial(expr * e) const;
     expr * mk_sin_value(rational const & k);
     app * mk_sqrt(rational const & k);
-    bool divides(expr* d, expr* n, expr_ref& quot);
+    bool divides(expr* d, expr* n, expr_ref& result);
+    expr_ref remove_divisor(expr* arg, expr* num, expr* den);
+    void flat_mul(expr* e, ptr_buffer<expr>& args);
+    void remove_divisor(expr* d, ptr_buffer<expr>& args);
 
 public:
     arith_rewriter(ast_manager & m, params_ref const & p = params_ref()):