z3str3: remove legacy code (#4215)

* z3str3: remove legacy fixed-length overlap testing

parameter smt.str.fixed_length_overlap_models has been deprecated

* z3str3: remove legacy length/value testing algorithm and binary search heuristic

the following parameters are deprecated:
smt.str.use_binary_search
smt.str.binary_search_start
smt.str.fixed_length_models (the fixed-length model construction is now always used)

* z3str3: remove legacy regex unroll methods

* z3str3: remove unused methods and member variables

Author: mtrberzi

src/ast/seq_decl_plugin.cpp

@@ -553,7 +553,6 @@ void seq_decl_plugin::init() {
     sort* str2TintT[3] = { strT, strT, intT };
     sort* seqAintT[2] = { seqA, intT };
     sort* seq3A[3] = { seqA, seqA, seqA };
-    sort* reTintT[2] = { reT, intT };
     m_sigs.resize(LAST_SEQ_OP);
     // TBD: have (par ..) construct and load parameterized signature from premable.
     m_sigs[OP_SEQ_UNIT]      = alloc(psig, m, "seq.unit",     1, 1, &A, seqA);
@@ -604,7 +603,6 @@ void seq_decl_plugin::init() {
     m_sigs[_OP_REGEXP_EMPTY]      = alloc(psig, m, "re.nostr", 0, 0, nullptr, reT);
     m_sigs[_OP_REGEXP_FULL_CHAR]  = alloc(psig, m, "re.allchar", 0, 0, nullptr, reT);
     m_sigs[_OP_STRING_SUBSTR]     = alloc(psig, m, "str.substr", 0, 3, strTint2T, strT);
-    m_sigs[_OP_RE_UNROLL]         = alloc(psig, m, "_re.unroll", 0, 2, reTintT, strT);
 }
 
 void seq_decl_plugin::set_manager(ast_manager* m, family_id id) {
@@ -772,11 +770,6 @@ func_decl * seq_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters,
         default:
             m.raise_exception("Incorrect number of arguments passed to loop. Expected 1 regular expression and two integer parameters");
         }
-        
-    case _OP_RE_UNROLL:
-        m_has_re = true;
-        match(*m_sigs[k], arity, domain, range, rng);
-        return m.mk_func_decl(m_sigs[k]->m_name, arity, domain, rng, func_decl_info(m_family_id, k));
 
     case OP_STRING_CONST:
         if (!(num_parameters == 1 && arity == 0 && parameters[0].is_symbol())) {

src/ast/seq_decl_plugin.h

@@ -86,7 +86,6 @@ enum seq_op_kind {
     _OP_REGEXP_EMPTY,
     _OP_REGEXP_FULL_CHAR,
     _OP_SEQ_SKOLEM,
-    _OP_RE_UNROLL,
     LAST_SEQ_OP
 };
 
@@ -415,7 +414,6 @@ class seq_util {
         bool is_loop(expr const* n, expr*& body, unsigned& lo);
         bool is_loop(expr const* n, expr*& body, expr*& lo, expr*& hi);
         bool is_loop(expr const* n, expr*& body, expr*& lo);
-        bool is_unroll(expr const* n) const { return is_app_of(n, m_fid, _OP_RE_UNROLL); }
     };
     str str;
     re  re;

src/smt/params/smt_params_helper.pyg

@@ -100,18 +100,13 @@ def_module_params(module_name='smt',
                           ('str.fast_length_tester_cache', BOOL, False, 'cache length tester constants instead of regenerating them'),
                           ('str.fast_value_tester_cache', BOOL, True, 'cache value tester constants instead of regenerating them'),
                           ('str.string_constant_cache', BOOL, True, 'cache all generated string constants generated from anywhere in theory_str'),
-                          ('str.use_binary_search', BOOL, False, 'use a binary search heuristic for finding concrete length values for free variables in theory_str (set to False to use linear search)'),
-                          ('str.binary_search_start', UINT, 64, 'initial upper bound for theory_str binary search'),
                           ('theory_aware_branching', BOOL, False, 'Allow the context to use extra information from theory solvers regarding literal branching prioritization.'),
-                          ('str.finite_overlap_models', BOOL, False, 'attempt a finite model search for overlapping variables instead of completely giving up on the arrangement'),
                           ('str.overlap_priority', DOUBLE, -0.1, 'theory-aware priority for overlapping variable cases; use smt.theory_aware_branching=true'),
-                          ('str.regex_automata', BOOL, True, 'use automata-based reasoning for regular expressions (Z3str3 only)'),
                           ('str.regex_automata_difficulty_threshold', UINT, 1000, 'difficulty threshold for regex automata heuristics'),
                           ('str.regex_automata_intersection_difficulty_threshold', UINT, 1000, 'difficulty threshold for regex intersection heuristics'),
                           ('str.regex_automata_failed_automaton_threshold', UINT, 10, 'number of failed automaton construction attempts after which a full automaton is automatically built'),
                           ('str.regex_automata_failed_intersection_threshold', UINT, 10, 'number of failed automaton intersection attempts after which intersection is always computed'),
                           ('str.regex_automata_length_attempt_threshold', UINT, 10, 'number of length/path constraint attempts before checking unsatisfiability of regex terms'),
-                          ('str.fixed_length_models', BOOL, True, 'use fixed-length equation solver to construct models (Z3str3 only)'),
                           ('str.fixed_length_refinement', BOOL, False, 'use abstraction refinement in fixed-length equation solver (Z3str3 only)'),
                           ('str.fixed_length_naive_cex', BOOL, True, 'construct naive counterexamples when fixed-length model construction fails for a given length assignment (Z3str3 only)'),
                           ('core.minimize', BOOL, False, 'minimize unsat core produced by SMT context'),

src/smt/params/theory_str_params.cpp

@@ -27,17 +27,12 @@ void theory_str_params::updt_params(params_ref const & _p) {
     m_UseFastLengthTesterCache = p.str_fast_length_tester_cache();
     m_UseFastValueTesterCache = p.str_fast_value_tester_cache();
     m_StringConstantCache = p.str_string_constant_cache();
-    m_FiniteOverlapModels = p.str_finite_overlap_models();
-    m_UseBinarySearch = p.str_use_binary_search();
-    m_BinarySearchInitialUpperBound = p.str_binary_search_start();
     m_OverlapTheoryAwarePriority = p.str_overlap_priority();
-    m_RegexAutomata = p.str_regex_automata();
     m_RegexAutomata_DifficultyThreshold = p.str_regex_automata_difficulty_threshold();
     m_RegexAutomata_IntersectionDifficultyThreshold = p.str_regex_automata_intersection_difficulty_threshold();
     m_RegexAutomata_FailedAutomatonThreshold = p.str_regex_automata_failed_automaton_threshold();
     m_RegexAutomata_FailedIntersectionThreshold = p.str_regex_automata_failed_intersection_threshold();
     m_RegexAutomata_LengthAttemptThreshold = p.str_regex_automata_length_attempt_threshold();
-    m_FixedLengthModels = p.str_fixed_length_models();
     m_FixedLengthRefinement = p.str_fixed_length_refinement();
     m_FixedLengthNaiveCounterexamples = p.str_fixed_length_naive_cex();
 }
@@ -52,15 +47,11 @@ void theory_str_params::display(std::ostream & out) const {
     DISPLAY_PARAM(m_UseFastLengthTesterCache);
     DISPLAY_PARAM(m_UseFastValueTesterCache);
     DISPLAY_PARAM(m_StringConstantCache);
-    DISPLAY_PARAM(m_UseBinarySearch);
-    DISPLAY_PARAM(m_BinarySearchInitialUpperBound);
     DISPLAY_PARAM(m_OverlapTheoryAwarePriority);
-    DISPLAY_PARAM(m_RegexAutomata);
     DISPLAY_PARAM(m_RegexAutomata_DifficultyThreshold);
     DISPLAY_PARAM(m_RegexAutomata_IntersectionDifficultyThreshold);
     DISPLAY_PARAM(m_RegexAutomata_FailedAutomatonThreshold);
     DISPLAY_PARAM(m_RegexAutomata_FailedIntersectionThreshold);
     DISPLAY_PARAM(m_RegexAutomata_LengthAttemptThreshold);
-    DISPLAY_PARAM(m_FixedLengthModels);
     DISPLAY_PARAM(m_FixedLengthNaiveCounterexamples);
 }

src/smt/params/theory_str_params.h

@@ -68,25 +68,8 @@ struct theory_str_params {
      */
     bool m_StringConstantCache;
 
-    /*
-     * If FiniteOverlapModels is set to true,
-     * arrangements that result in overlapping variables will generate a small number of models
-     * to test instead of completely giving up on the case.
-     */
-    bool m_FiniteOverlapModels;
-
-    bool m_UseBinarySearch;
-    unsigned m_BinarySearchInitialUpperBound;
-
     double m_OverlapTheoryAwarePriority;
 
-    /*
-     * If RegexAutomata is set to true,
-     * Z3str3 will use automata-based methods to reason about
-     * regular expression constraints.
-     */
-    bool m_RegexAutomata;
-
     /*
      * RegexAutomata_DifficultyThreshold is the lowest difficulty above which Z3str3
      * will not eagerly construct an automaton for a regular expression term.
@@ -116,13 +99,6 @@ struct theory_str_params {
      * before which we begin checking unsatisfiability of a regex term.
      */
     unsigned m_RegexAutomata_LengthAttemptThreshold;
-    
-    /*
-     * If FixedLengthModels is true, Z3str3 will use a fixed-length equation solver to construct models in final_check.
-     * If false, Z3str3 will use the legacy length tester and value tester procedure.
-     */
-    bool m_FixedLengthModels;
-
     /*
      * If FixedLengthRefinement is true and the fixed-length equation solver is enabled,
      * Z3str3 will use abstraction refinement to handle formulas that would result in disjunctions or expensive
@@ -145,17 +121,12 @@ struct theory_str_params {
         m_UseFastLengthTesterCache(false),
         m_UseFastValueTesterCache(true),
         m_StringConstantCache(true),
-        m_FiniteOverlapModels(false),
-        m_UseBinarySearch(false),
-        m_BinarySearchInitialUpperBound(64),
         m_OverlapTheoryAwarePriority(-0.1),
-        m_RegexAutomata(true),
         m_RegexAutomata_DifficultyThreshold(1000),
         m_RegexAutomata_IntersectionDifficultyThreshold(1000),
         m_RegexAutomata_FailedAutomatonThreshold(10),
         m_RegexAutomata_FailedIntersectionThreshold(10),
         m_RegexAutomata_LengthAttemptThreshold(10),
-        m_FixedLengthModels(true),
         m_FixedLengthRefinement(false),
         m_FixedLengthNaiveCounterexamples(true)
     {