add missing tactic descriptions, add rewrite for tamagochi

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

src/ast/rewriter/bool_rewriter.cpp

@@ -857,6 +857,7 @@ br_status bool_rewriter::mk_ite_core(expr * c, expr * t, expr * e, expr_ref & re
         s = true;
     }
 
+
     // (ite c (ite c t1 t2) t3)       ==> (ite c t1 t3
     if (m().is_ite(t) && to_app(t)->get_arg(0) == c) {
         // Remark: (ite c (ite (not c) t1 t2) t3) ==> (ite c t2 t3) does not happen if applying rewrites bottom up
@@ -943,7 +944,6 @@ br_status bool_rewriter::mk_ite_core(expr * c, expr * t, expr * e, expr_ref & re
     }
 
 #if 0
-    expr* t1, *t2;
     // (ite c (not (= t1 t2)) t1) ==> (not (= t1 (and c t2)))
     if (m().is_not(t, t1) && m().is_eq(t1, t1, t2) && e == t1) {
         expr_ref a(m());
@@ -960,6 +960,8 @@ br_status bool_rewriter::mk_ite_core(expr * c, expr * t, expr * e, expr_ref & re
 #endif
 
 
+
+
     if (m().is_ite(t) && m_ite_extra_rules && m_elim_ite) {
         // (ite c1 (ite c2 t1 t2) t1) ==> (ite (and c1 (not c2)) t2 t1)
         if (e == to_app(t)->get_arg(1)) {

src/ast/rewriter/bv_rewriter.cpp

@@ -2807,6 +2807,28 @@ br_status bv_rewriter::mk_mkbv(unsigned num, expr * const * args, expr_ref & res
     return BR_FAILED;
 }
 
+bool bv_rewriter::is_bit(expr* t, unsigned& val) {
+    rational v;
+    unsigned sz;
+    return is_bv(t) && is_numeral(t, v, sz) && sz == 1 && (val = v.get_unsigned(), true);
+}
+
+bool bv_rewriter::is_eq_bit(expr * t, expr * & x, unsigned & val) {
+    expr* lhs, *rhs;
+    if (!m.is_eq(t, lhs, rhs))
+        return false;
+    if (is_bit(lhs, val)) {
+        x = rhs;
+        return true;
+    }
+    if (is_bit(rhs, val)) {
+        x = lhs;
+        return true;
+    }
+    return false;
+}
+
+
 br_status bv_rewriter::mk_ite_core(expr * c, expr * t, expr * e, expr_ref & result) {
     TRACE("bv_ite", tout << "mk_ite_core:\n" << mk_ismt2_pp(c, m) << "?\n"
             << mk_ismt2_pp(t, m) << "\n:" << mk_ismt2_pp(e, m) << "\n";);
@@ -2819,6 +2841,20 @@ br_status bv_rewriter::mk_ite_core(expr * c, expr * t, expr * e, expr_ref & resu
         return BR_REWRITE1;
     }
 
+    // if x = 0 then 0 else 1
+    expr* t1;
+    unsigned bit1, bit2, bit3;
+    if (is_bv(t) && is_eq_bit(c, t1, bit1) && is_bit(t, bit2) && is_bit(e, bit3)) {
+        if (bit1 == bit2 && bit3 != bit2) {
+            result = t1;
+            return BR_DONE;
+        }            
+        if (bit1 == bit3 && bit3 != bit2) {
+            result = m_util.mk_bv_not(t1);
+            return BR_REWRITE1;
+        }
+    }
+
     if (m_ite2id && m.is_eq(c) && is_bv(t) && is_bv(e)) {
         // detect when ite is actually some simple function based on the pattern (lhs=rhs) ? t : e
         expr * lhs = to_app(c)->get_arg(0);

src/ast/rewriter/bv_rewriter.h

@@ -193,6 +193,16 @@ public:
 
     bv_util & get_util() { return m_util; }
 
+    // Return true if t is of the form
+    //    (= t #b0)
+    //    (= t #b1)
+    //    (= #b0 t)
+    //    (= #b1 t)
+    bool is_eq_bit(expr* t, expr*& x, unsigned& val);
+
+    // return true if t is #b0 or #b1
+    bool is_bit(expr* t, unsigned& val);
+
 #define MK_BV_BINARY(OP)                         \
     expr_ref OP(expr* a, expr* b) {              \
         expr_ref result(m);                    \

src/ast/rewriter/th_rewriter.cpp

@@ -125,36 +125,6 @@ struct th_rewriter_cfg : public default_rewriter_cfg {
         return num_steps > m_max_steps;
     }
 
-    // Return true if t is of the form
-    //    (= t #b0)
-    //    (= t #b1)
-    //    (= #b0 t)
-    //    (= #b1 t)
-    bool is_eq_bit(expr * t, expr * & x, unsigned & val) {
-        if (!m().is_eq(t))
-            return false;
-        expr * lhs = to_app(t)->get_arg(0);
-        if (!m_bv_rw.is_bv(lhs))
-            return false;
-        if (m_bv_rw.get_bv_size(lhs) != 1)
-            return false;
-        expr * rhs = to_app(t)->get_arg(1);
-        rational v;
-        unsigned sz;
-        if (m_bv_rw.is_numeral(lhs, v, sz)) {
-            x    = rhs;
-            val  = v.get_unsigned();
-            SASSERT(val == 0 || val == 1);
-            return true;
-        }
-        if (m_bv_rw.is_numeral(rhs, v, sz)) {
-            x   = lhs;
-            val  = v.get_unsigned();
-            SASSERT(val == 0 || val == 1);
-            return true;
-        }
-        return false;
-    }
 
     // (iff (= x bit1) A)
     // --->
@@ -162,11 +132,11 @@ struct th_rewriter_cfg : public default_rewriter_cfg {
     br_status apply_tamagotchi(expr * lhs, expr * rhs, expr_ref & result) {
         expr * x;
         unsigned val;
-        if (is_eq_bit(lhs, x, val)) {
+        if (m_bv_rw.is_eq_bit(lhs, x, val)) {
             result = m().mk_eq(x, m().mk_ite(rhs, m_bv_rw.mk_numeral(val, 1), m_bv_rw.mk_numeral(1-val, 1)));
             return BR_REWRITE2;
         }
-        if (is_eq_bit(rhs, x, val)) {
+        if (m_bv_rw.is_eq_bit(rhs, x, val)) {
             result = m().mk_eq(x, m().mk_ite(lhs, m_bv_rw.mk_numeral(val, 1), m_bv_rw.mk_numeral(1-val, 1)));
             return BR_REWRITE2;
         }