NYI control paths

src/smt/asserted_formulas.cpp

@@ -138,7 +138,7 @@ void asserted_formulas::set_eliminate_and(bool flag) {
     //m_params.set_bool("expand_nested_stores", true);
     m_params.set_bool("bv_sort_ac", true);
     // seq theory solver keeps terms in normal form and has to interact with side-effect of rewriting
-    // m_params.set_bool("coalesce_chars", m_smt_params.m_string_solver != symbol("seq"));
+    m_params.set_bool("coalesce_chars", m_smt_params.m_string_solver != symbol("seq"));
     m_params.set_bool("som", true);
     m_rewriter.updt_params(m_params);
     flush_cache();

src/smt/smt_induction.cpp

@@ -217,11 +217,22 @@ void create_induction_lemmas::filter_abstractions(bool sign, abstractions& abs)
  * lit & a.eqs() => alpha
  * lit & a.eqs() & is-c(t) => ~beta
  *
- * where alpha = a.term()
+ * where 
+ *       lit   = is a formula containing t
+ *       alpha = a.term(), a variant of lit 
+ *               with some occurrences of t replaced by sk
  *       beta  = alpha[sk/access_k(sk)]
  * for each constructor c, that is recursive 
  * and contains argument of datatype sort s
  *
+ * The main claim is that the lemmas are valid and that
+ * they approximate induction reasoning.
+ * 
+ * alpha approximates minimal instance of the datatype s where 
+ * the instance of s is true. In the limit one can
+ * set beta to all instantiations of smaller values than sk.
+ * 
+ * 
  * TBD: consider k-inductive lemmas.
  */
 void create_induction_lemmas::create_lemmas(expr* t, expr* sk, abstraction& a, literal lit) {

src/smt/theory_seq.cpp

@@ -1050,9 +1050,6 @@ bool theory_seq::add_solution(expr* l, expr* r, dependency* deps)  {
     }
     m_new_solution = true;
     m_rep.update(l, r, deps);
-    expr_ref sl(l, m);
-    m_rewrite(sl);
-    m_rep.update(sl, r, deps);
     enode* n1 = ensure_enode(l);
     enode* n2 = ensure_enode(r);    
     TRACE("seq", tout << mk_bounded_pp(l, m, 2) << " ==> " << mk_bounded_pp(r, m, 2) << "\n"; display_deps(tout, deps);