fixes for #2513

Signed-off-by: Nikolaj Bjorner <[email protected]>

Author: NikolajBjorner

src/ast/rewriter/seq_rewriter.cpp

@@ -21,6 +21,7 @@ Module Name:
 #include "ast/rewriter/seq_rewriter.h"
 #include "ast/arith_decl_plugin.h"
 #include "ast/ast_pp.h"
+#include "ast/ast_ll_pp.h"
 #include "ast/ast_util.h"
 #include "util/uint_set.h"
 #include "math/automata/automaton.h"
@@ -546,7 +547,7 @@ br_status seq_rewriter::mk_app_core(func_decl * f, unsigned num_args, expr * con
     case _OP_STRING_STRIDOF: 
         UNREACHABLE();
     }
-    CTRACE("seq", st != BR_FAILED, tout << result << "\n";);
+    CTRACE("seq_verbose", st != BR_FAILED, tout << result << "\n";);
     return st;
 }
 
@@ -643,14 +644,38 @@ br_status seq_rewriter::mk_seq_length(expr* a, expr_ref& result) {
         result = m_autil.mk_add(es.size(), es.c_ptr());
         return BR_REWRITE2;
     }
+    expr* c = nullptr, *t = nullptr, *e = nullptr;
+    if (m().is_ite(a, c, t, e) && (t->get_ref_count() == 1 || e->get_ref_count() == 1)) {
+        result = m().mk_ite(c, m_util.str.mk_length(t), m_util.str.mk_length(e));
+        return BR_REWRITE3;
+    }
+#if 0
+    expr* s = nullptr, *offs = nullptr, *l = nullptr;
+    // len(extract(s, offs, len(s) - offs)) = max(0, len(s) - offs)
+    // 
+    if (m_util.str.is_extract(a, s, offs, l) && is_suffix(s, offs, l)) {
+        expr_ref zero(m_autil.mk_int(0), m());
+        result = m_autil.mk_sub(m_util.str.mk_length(s), offs);
+        result = m().mk_ite(m_autil.mk_ge(result, zero), result, zero);
+        return BR_REWRITE_FULL;
+    }
+#endif
     return BR_FAILED;
 }
 
+bool seq_rewriter::is_suffix(expr* s, expr* offset, expr* len) {
+    expr_ref_vector lens(m());
+    rational a, b;
+    return 
+        get_lengths(len, lens, a) && 
+        (a.neg(), m_autil.is_numeral(offset, b) && b.is_pos() && a == b);
+}
+
 br_status seq_rewriter::mk_seq_extract(expr* a, expr* b, expr* c, expr_ref& result) {
     zstring s;
     rational pos, len;
 
-    TRACE("seq", tout << mk_pp(a, m()) << " " << mk_pp(b, m()) << " " << mk_pp(c, m()) << "\n";);
+    TRACE("seq_verbose", tout << mk_pp(a, m()) << " " << mk_pp(b, m()) << " " << mk_pp(c, m()) << "\n";);
     bool constantBase = m_util.str.is_string(a, s);
     bool constantPos = m_autil.is_numeral(b, pos);
     bool constantLen = m_autil.is_numeral(c, len);
@@ -702,7 +727,8 @@ br_status seq_rewriter::mk_seq_extract(expr* a, expr* b, expr* c, expr_ref& resu
         m_lhs.reset();
         expr_ref_vector lens(m());
         m_util.str.get_concat(a, m_lhs);
-        if (!get_lengths(b, lens, pos)) {
+        TRACE("seq", tout << m_lhs << " " << pos << " " << lens << "\n";);
+        if (!get_lengths(b, lens, pos) || pos.is_neg()) {
             return BR_FAILED;
         }
         unsigned i = 0;
@@ -742,9 +768,20 @@ br_status seq_rewriter::mk_seq_extract(expr* a, expr* b, expr* c, expr_ref& resu
 
     // (extract s 0 (len s)) = s 
     expr* a2 = nullptr;
-    if (_pos == 0 && m_util.str.is_length(c, a2) && a == a2) {
-        result = a;
-        return BR_DONE;
+    if (_pos == 0 && m_util.str.is_length(c, a2)) {
+        m_lhs.reset();
+        m_util.str.get_concat(a, m_lhs);
+        if (!m_lhs.empty() && m_lhs.get(0) == a2) {
+            result = a2;
+            return BR_DONE;
+        }
+    }
+
+    expr* a1 = nullptr, *b1 = nullptr, *c1 = nullptr;
+    if (m_util.str.is_extract(a, a1, b1, c1) && 
+        is_suffix(a1, b1, c1) && is_suffix(a, b, c)) {
+        result = m_util.str.mk_substr(a1, m_autil.mk_add(b1, b), m_autil.mk_sub(c1, b));
+        return BR_REWRITE3;
     }
 
     unsigned offset = 0;
@@ -799,7 +836,7 @@ bool seq_rewriter::get_lengths(expr* e, expr_ref_vector& lens, rational& pos) {
     else {
         return false;
     }
-    return !pos.is_neg();
+    return true;
 }
 
 bool seq_rewriter::cannot_contain_suffix(expr* a, expr* b) {
@@ -992,9 +1029,28 @@ br_status seq_rewriter::mk_seq_at(expr* a, expr* b, expr_ref& result) {
 }
 
 br_status seq_rewriter::mk_seq_nth(expr* a, expr* b, expr_ref& result) {
+
+    rational pos1, pos2;
+    expr* s = nullptr, *p = nullptr, *len = nullptr;
+    if (m_util.str.is_unit(a, s) && m_autil.is_numeral(b, pos1) && pos1.is_zero()) {
+        result = s;
+        return BR_DONE;
+    }
+    if (m_util.str.is_extract(a, s, p, len) && m_autil.is_numeral(p, pos1)) {
+        expr_ref_vector lens(m());
+        rational pos2;
+        if (get_lengths(len, lens, pos2) && (pos1 == -pos2) && (lens.size() == 1) && (lens.get(0) == s)) {
+            expr_ref idx(m_autil.mk_int(pos1), m());
+            idx = m_autil.mk_add(b, idx);
+            expr* es[2] = { s, idx };
+            result = m().mk_app(m_util.get_family_id(), OP_SEQ_NTH, 2, es);
+            return BR_REWRITE_FULL;
+        }
+    }
+
     expr* es[2] = { a, b};
     expr* la = m_util.str.mk_length(a);
-    result = m().mk_ite(m().mk_and(m_autil.mk_le(m_autil.mk_int(0), b), m_autil.mk_lt(b, la)), 
+    result = m().mk_ite(m().mk_and(m_autil.mk_ge(b, m_autil.mk_int(0)), m().mk_not(m_autil.mk_ge(b, la))), 
                         m().mk_app(m_util.get_family_id(), OP_SEQ_NTH_I, 2, es), 
                         m().mk_app(m_util.get_family_id(), OP_SEQ_NTH_U, 2, es));
     return BR_REWRITE_FULL;
@@ -1078,10 +1134,26 @@ br_status seq_rewriter::mk_seq_replace(expr* a, expr* b, expr* c, expr_ref& resu
         result = a;
         return BR_DONE;
     }
+    if (a == b) {
+        result = c;
+        return BR_DONE;
+    }
     if (m_util.str.is_empty(b)) {
         result = m_util.str.mk_concat(c, a);
         return BR_REWRITE1;
     }
+    
+    if (m_util.str.is_string(b, s2)) {
+        m_lhs.reset();
+        m_util.str.get_concat(a, m_lhs);
+        if (!m_lhs.empty() && m_util.str.is_string(m_lhs.get(0), s1) && 
+            s1.contains(s2)) {
+            m_lhs[0] = m_util.str.mk_string(s1.replace(s2, s3));
+            result = m_util.str.mk_concat(m_lhs.size(), m_lhs.c_ptr());
+            return BR_REWRITE1;
+        }
+    }
+
     return BR_FAILED;
 }
 
@@ -1835,7 +1907,7 @@ bool seq_rewriter::reduce_eq(expr_ref_vector& ls, expr_ref_vector& rs, expr_ref_
     zstring s;
     bool lchange = false;
     SASSERT(lhs.empty());
-    TRACE("seq", tout << ls << "\n"; tout << rs << "\n";);
+    TRACE("seq_verbose", tout << ls << "\n"; tout << rs << "\n";);
     // solve from back
     while (true) {
         while (!rs.empty() && m_util.str.is_empty(rs.back())) {
@@ -1943,7 +2015,7 @@ bool seq_rewriter::reduce_eq(expr_ref_vector& ls, expr_ref_vector& rs, expr_ref_
         else {
             break;
         }
-        TRACE("seq", tout << ls << " == " << rs << "\n";);
+        TRACE("seq_verbose", tout << ls << " == " << rs << "\n";);
 
         change = true;
         lchange = true;
@@ -2106,7 +2178,7 @@ bool seq_rewriter::reduce_eq(expr* l, expr* r, expr_ref_vector& lhs, expr_ref_ve
         return true;
     }
     else {
-        TRACE("seq", tout << mk_pp(l, m()) << " != " << mk_pp(r, m()) << "\n";);
+        TRACE("seq", tout << mk_bounded_pp(l, m()) << " != " << mk_bounded_pp(r, m()) << "\n";);
         return false;
     }
 }

src/ast/rewriter/seq_rewriter.h

@@ -139,6 +139,8 @@ class seq_rewriter {
     bool cannot_contain_prefix(expr* a, expr* b);
     bool cannot_contain_suffix(expr* a, expr* b);
 
+    bool is_suffix(expr* s, expr* offset, expr* len);
+
     bool set_empty(unsigned sz, expr* const* es, bool all, expr_ref_vector& lhs, expr_ref_vector& rhs);
     bool is_subsequence(unsigned n, expr* const* l, unsigned m, expr* const* r, 
                         expr_ref_vector& lhs, expr_ref_vector& rhs, bool& is_sat);

src/ast/static_features.cpp

@@ -346,9 +346,7 @@ void static_features::update_core(expr * e) {
                 m_num_uninterpreted_functions++;
         }
         if (!_is_eq && !_is_gate) {
-            unsigned num_args = to_app(e)->get_num_args();
-            for (unsigned i = 0; i < num_args; i++) {
-                expr * arg   = to_app(e)->get_arg(i);
+            for (expr * arg : *to_app(e)) {
                 sort * arg_s = m_manager.get_sort(arg); 
                 if (!m_manager.is_uninterp(arg_s)) {
                     family_id fid_arg = arg_s->get_family_id();

src/cmd_context/cmd_context.cpp

@@ -36,6 +36,7 @@ Module Name:
 #include "ast/rewriter/var_subst.h"
 #include "ast/pp.h"
 #include "ast/ast_smt2_pp.h"
+#include "ast/ast_ll_pp.h"
 #include "ast/decl_collector.h"
 #include "ast/well_sorted.h"
 #include "ast/for_each_expr.h"
@@ -1896,7 +1897,7 @@ void cmd_context::validate_model() {
                     continue;
                 }
                 TRACE("model_validate", model_smt2_pp(tout, *this, *md, 0););
-                IF_VERBOSE(10, verbose_stream() << "model check failed on: " << mk_pp(a, m()) << "\n";);                
+                analyze_failure(evaluator, a, true);
                 IF_VERBOSE(11, model_smt2_pp(verbose_stream(), *this, *md, 0););                
                 invalid_model = true;
             }
@@ -1907,6 +1908,73 @@ void cmd_context::validate_model() {
     }
 }
 
+void cmd_context::analyze_failure(model_evaluator& ev, expr* a, bool expected_value) {
+    if (expected_value && m().is_and(a)) {
+        for (expr* arg : *to_app(a)) {
+            if (ev.is_false(arg)) {
+                analyze_failure(ev, arg, true);
+                return;
+            }
+        }
+    }
+    expr* c = nullptr, *t = nullptr, *e = nullptr;
+    if (expected_value && m().is_ite(a, c, t, e)) {
+        if (ev.is_true(c) && ev.is_false(t)) {
+            analyze_failure(ev, t, true);
+            return;
+        }
+        if (ev.is_false(c) && ev.is_false(e)) {
+            analyze_failure(ev, e, true);
+            return;
+        }
+    }
+    if (m().is_not(a, e)) {
+        analyze_failure(ev, e, !expected_value);
+        return;
+    }
+    if (!expected_value && m().is_or(a)) {
+        for (expr* arg : *to_app(a)) {
+            if (ev.is_false(arg)) {
+                analyze_failure(ev, arg, false);
+                return;
+            }
+        }
+    }
+    if (!expected_value && m().is_ite(a, c, t, e)) {
+        if (ev.is_true(c) && ev.is_true(t)) {
+            analyze_failure(ev, t, false);
+            return;
+        }
+        if (ev.is_false(c) && ev.is_true(e)) {
+            analyze_failure(ev, e, false);
+            return;
+        }
+    }
+    IF_VERBOSE(10, verbose_stream() << "model check failed on: " << " " << mk_pp(a, m()) << "\n";);                
+    IF_VERBOSE(10, verbose_stream() << "expected value: " << (expected_value?"true":"false") << "\n";);                
+
+    IF_VERBOSE(10, display_detailed_analysis(verbose_stream(), ev, a));
+}
+
+void cmd_context::display_detailed_analysis(std::ostream& out, model_evaluator& ev, expr* e) {
+    ptr_vector<expr> es;
+    es.push_back(e);
+    expr_mark visited;
+    for (unsigned i = 0; i < es.size(); ++i) {
+        e = es[i];
+        if (visited.is_marked(e)) {
+            continue;
+        }
+        visited.mark(e, true);
+        expr_ref val = ev(e);
+        out << "#" << e->get_id() << ": " << mk_bounded_pp(e, m(), 1) << " " << val << "\n";
+        if (is_app(e)) {
+            for (expr* arg : *to_app(e)) {
+                es.push_back(arg);
+            }
+        }
+    }
+}
 
 void cmd_context::mk_solver() {
     bool proofs_enabled, models_enabled, unsat_core_enabled;

src/cmd_context/cmd_context.h

@@ -367,6 +367,8 @@ class cmd_context : public progress_callback, public tactic_manager, public ast_
     check_sat_state cs_state() const;
     void complete_model(model_ref& mdl) const;
     void validate_model();
+    void analyze_failure(model_evaluator& ev, expr* e, bool expected_value);
+    void display_detailed_analysis(std::ostream& out, model_evaluator& ev, expr* e);
     void display_model(model_ref& mdl);
 
     void register_plugin(symbol const & name, decl_plugin * p, bool install_names);

src/qe/nlqsat.cpp

@@ -641,6 +641,7 @@ namespace qe {
                     }
                 }
                 fml = mk_and(paxioms);
+                std::cout << fml << "\n";
             }
         }
 

src/sat/sat_config.cpp

@@ -181,6 +181,7 @@ namespace sat {
         m_drat_file       = p.drat_file();
         m_drat            = (m_drat_check_unsat || m_drat_file != symbol("") || m_drat_check_sat) && p.threads() == 1;
         m_drat_binary     = p.drat_binary();
+        m_drat_activity   = p.drat_activity();
         m_dyn_sub_res     = p.dyn_sub_res();
 
         // Parameters used in Liang, Ganesh, Poupart, Czarnecki AAAI 2016.

src/sat/sat_config.h

@@ -168,6 +168,7 @@ namespace sat {
         symbol             m_drat_file;
         bool               m_drat_check_unsat;
         bool               m_drat_check_sat;
+        bool               m_drat_activity;
 
         bool               m_card_solver;
         bool               m_xor_solver;