Add new string repair heuristic (#7496)

* Fixed spurious counterexamples in seq-sls. Updates might not be identity mapping

* Removed debug code

* One check was missing

* Trying different update generation function

* Renamed function

* Added parameter to select string update function

src/ast/sls/sls_seq_plugin.cpp

@@ -95,10 +95,18 @@ Equality solving using stochastic Nelson.
 #include "ast/sls/sls_seq_plugin.h"
 #include "ast/sls/sls_context.h"
 #include "ast/ast_pp.h"
+#include "params/sls_params.hpp"
 
 
 namespace sls {
 
+    struct zstring_hash_proc {
+        unsigned operator()(zstring const & s) const {
+            auto str = s.encode();
+            return string_hash(str.c_str(), static_cast<unsigned>(s.length()), 17);
+        }
+    };
+    
     seq_plugin::seq_plugin(context& c):
         plugin(c),
         seq(c.get_manager()),
@@ -107,6 +115,8 @@ namespace sls {
         thrw(c.get_manager())
     {
         m_fid = seq.get_family_id();
+        sls_params p(c.get_params());
+        m_str_update_strategy = p.str_update_strategy() == 0 ? EDIT_CHAR : EDIT_SUBSTR;
     }
     
     void seq_plugin::propagate_literal(sat::literal lit) {
@@ -665,8 +675,39 @@ namespace sls {
         return d[n][m];
     }
 
-
     void seq_plugin::add_edit_updates(ptr_vector<expr> const& w, zstring const& val, zstring const& val_other, uint_set const& chars) {
+        if (m_str_update_strategy == EDIT_CHAR)
+            add_char_edit_updates(w, val, val_other, chars);
+        else
+            add_substr_edit_updates(w, val, val_other, chars);
+    }
+
+    void seq_plugin::add_substr_edit_updates(ptr_vector<expr> const& w, zstring const& val, zstring const& val_other, uint_set const& chars) {
+        // all consecutive subsequences of val_other
+        hashtable<zstring, zstring_hash_proc, default_eq<zstring>> set;
+        set.insert(zstring(""));
+        for (unsigned i = 0; i < val_other.length(); ++i) {
+            for (unsigned j = val_other.length(); j > 0; ++j) {
+                zstring sub = val_other.extract(i, j);
+                if (set.contains(sub))
+                    break;
+                set.insert(sub);
+            }
+        }
+
+        for (auto x : w) {
+            if (is_value(x))
+                continue;
+            zstring const& a = strval0(x);
+            for (auto& seq : set) {
+                if (seq == a)
+                    continue;
+                m_str_updates.push_back({ x, seq, 1 });
+            }
+        }
+    }
+
+    void seq_plugin::add_char_edit_updates(ptr_vector<expr> const& w, zstring const& val, zstring const& val_other, uint_set const& chars) {
         for (auto x : w) {
             if (is_value(x))
                 continue;
@@ -1436,13 +1477,13 @@ namespace sls {
                 if (idx > 0)
                     su = sa.extract(0, idx);
                 su = su + sa.extract(idx + sb.length(), sa.length() - idx - sb.length());            
-                m_str_updates.push_back({a, su, 1});
+                m_str_updates.push_back({ a, su, 1});
             }
             if (!m_chars.empty() && !is_value(b)) {
                 zstring sb1 = sb + zstring(m_chars[ctx.rand(m_chars.size())]);
                 zstring sb2 = zstring(m_chars[ctx.rand(m_chars.size())]) + sb;
-                m_str_updates.push_back({b, sb1, 1});
+                m_str_updates.push_back({ b, sb1, 1});
-                m_str_updates.push_back({b, sb2, 1});
+                m_str_updates.push_back({ b, sb2, 1});
             }
         }
         return apply_update();

src/ast/sls/sls_seq_plugin.h

@@ -42,6 +42,11 @@ namespace sls {
             ptr_vector<expr> lhs, rhs;
         };
 
+        enum edit_distance_strategy {
+            EDIT_CHAR,
+            EDIT_SUBSTR,
+        };
+
         seq_util seq;
         arith_util a;
         seq_rewriter rw;
@@ -49,6 +54,7 @@ namespace sls {
         scoped_ptr_vector<eval> m_values;
         indexed_uint_set m_chars; // set of characters in the problem
         bool m_initialized = false;
+        edit_distance_strategy m_str_update_strategy;
 
         struct str_update {
             expr* e;
@@ -122,6 +128,8 @@ namespace sls {
         unsigned edit_distance_with_updates(string_instance const& a, string_instance const& b);
         unsigned edit_distance(zstring const& a, zstring const& b);
         void add_edit_updates(ptr_vector<expr> const& w, zstring const& val, zstring const& val_other, uint_set const& chars);
+        void add_char_edit_updates(ptr_vector<expr> const& w, zstring const& val, zstring const& val_other, uint_set const& chars);
+        void add_substr_edit_updates(ptr_vector<expr> const& w, zstring const& val, zstring const& val_other, uint_set const& chars);
 
         // regex functionality
         

src/params/sls_params.pyg

@@ -24,5 +24,6 @@ def_module_params('sls',
                         ('rescore', BOOL, 1, 'rescore/normalize top-level score every base restart interval'),
                         ('dt_axiomatic', BOOL, True, 'use axiomatic mode or model reduction for datatype solver'),
                         ('track_unsat', BOOL, 0, 'keep a list of unsat assertions as done in SAT - currently disabled internally'),
-                        ('random_seed', UINT, 0, 'random seed')
+                        ('random_seed', UINT, 0, 'random seed'),
+                        ('str_update_strategy', UINT, 1, 'string update candidate selection: 0 - single character based update, 1 - subsequence based update')
               ))