seq_monadic: replace solve_and with incremental add()/check() API

Replace the batch solve_and(mems) with an incremental interface:
  void add(expr* term, expr* regex, u_dependency* d);
  lbool check();
add() stores each (term, regex, dependency) triple in
m_memberships (vector<tuple<expr_ref, expr_ref, u_dependency*>>); the
dependency is retained for future unsat-core tracking and may be nullptr.
check() decides the accumulated conjunction (the former solve_and body) and
consumes the memberships; an empty conjunction is sat. Update the unit tests
and benchmark to the add()/check() API.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: 57b9b87e-950a-49ea-bbb3-ed585646a5a9

src/ast/rewriter/seq_monadic.cpp

@@ -420,9 +420,16 @@ lbool seq_monadic::decide_dnf(vector<disjunct> const& dnf) {
     return any_undef ? l_undef : l_false;
 }
 
-lbool seq_monadic::solve_and(vector<std::pair<expr*, expr*>> const& mems) {
-    if (mems.empty())
-        return l_undef;
+void seq_monadic::add(expr* term, expr* regex, u_dependency* d) {
+    m_memberships.push_back({ expr_ref(term, m), expr_ref(regex, m), d });
+}
+
+lbool seq_monadic::check() {
+    m_model.reset();
+    vector<std::tuple<expr_ref, expr_ref, u_dependency*>> memberships;
+    memberships.swap(m_memberships);              // consume the asserted memberships
+    if (memberships.empty())
+        return l_true;                            // empty conjunction is vacuously true
     m_pin.reset();
     reset_cofactor_cache();
     m_budget = 200000;
@@ -434,16 +441,16 @@ lbool seq_monadic::solve_and(vector<std::pair<expr*, expr*>> const& mems) {
     vector<disjunct> combined;
     combined.push_back(disjunct());               // { true }
     const unsigned DNF_CAP = 1u << 14;
-    for (auto const& tr : mems) {
+    for (auto const& [term, regex, d] : memberships) {
         vector<disjunct> dnf_i;
-        if (!build_membership_dnf(tr.first, tr.second, dnf_i))
+        if (!build_membership_dnf(term, regex, dnf_i))
             return l_undef;
         vector<disjunct> next;
-        for (disjunct const& d : combined) {
+        for (disjunct const& cd : combined) {
             for (disjunct const& e : dnf_i) {
                 if (next.size() > DNF_CAP || m_budget == 0) { m_giveup = true; return l_undef; }
                 --m_budget;
-                disjunct D(d);
+                disjunct D(cd);
                 for (auto const& c : e)
                     D.push_back(c);
                 next.push_back(D);

src/ast/rewriter/seq_monadic.h

@@ -43,7 +43,7 @@ Abstract:
 
     Supports single / multiple / repeated variables.  Per-variable extra constraints
     (e.g. a base membership intersected with a length-regex) are expressed as an extra
-    membership passed to `solve_and`.
+    membership passed to `add` and decided by `check`.
 
 Author:
 
@@ -57,7 +57,9 @@ Author:
 #include "ast/rewriter/th_rewriter.h"
 #include "util/lbool.h"
 #include "util/obj_hashtable.h"
+#include "util/dependency.h"
 #include <utility>
+#include <tuple>
 
 class seq_monadic {
 public:
@@ -77,9 +79,10 @@ private:
     expr_ref_vector m_pin;                  // pins derivative states / witnesses referenced later
     unsigned        m_budget = 0;           // global work budget (decompose disjuncts + product pops)
     bool            m_giveup = false;       // set when the budget is exhausted
-    bool            m_gen_model = true;     // whether solve()/solve_and() extract a feasible model
+    bool            m_gen_model = true;     // whether solve()/check() extract a feasible model
     obj_map<expr, expr*> m_model;           // last extracted model (var -> witness); see get_model()
     obj_map<expr, expr_ref_pair_vector*> m_cofactor_cache;  // memoizes derivative_cofactors per regex
+    vector<std::tuple<expr_ref, expr_ref, u_dependency*>> m_memberships;  // asserted (term in regex, dep) for check()
 
     seq_util&      u() const { return m_rw.u(); }
     seq_util::rex& re() const { return m_rw.u().re; }
@@ -100,7 +103,7 @@ private:
 
     // Symbolic transition cofactors in the selected mode.  Memoized per regex `r`: the
     // returned vector is owned by the cofactor cache and stays valid until the next
-    // top-level solve()/solve_and() (which resets the cache).
+    // top-level solve()/check() (which resets the cache).
     expr_ref_pair_vector const& derivative_cofactors(expr* r);
 
     // Drop all memoized cofactors and free their owned vectors.
@@ -147,13 +150,13 @@ public:
     transition_mode mode() const { return m_mode; }
 
     // Enable/disable model generation (default: enabled).  When enabled, a successful
-    // solve()/solve_and() extracts a feasible model retrievable via get_model().
+    // solve()/check() extracts a feasible model retrievable via get_model().
     void set_gen_model(bool b) { m_gen_model = b; }
 
-    // The model extracted by the last successful solve()/solve_and(): var -> witness,
+    // The model extracted by the last successful solve()/check(): var -> witness,
     // where each witness is a concrete sequence term (over the element sort) giving one
     // satisfying assignment.  Witness terms are pinned by the solver and remain valid
-    // until the next solve()/solve_and().  Only valid when model generation is enabled.
+    // until the next solve()/check().  Only valid when model generation is enabled.
     obj_map<expr, expr*> const& get_model() const { return m_model; }
 
     // Decide  (str.in_re term R)  for a term that is a concatenation of string variables
@@ -161,12 +164,18 @@ public:
     //   l_true = sat, l_false = unsat, l_undef = unsupported shape / gave up.
     lbool solve(expr* term, expr* R);
 
-    // Decide a CONJUNCTION of memberships  AND_i (term_i in R_i)  jointly: a variable
+    // Assert a membership  (term in regex)  to be decided jointly by the next check().
+    // `d` carries the dependency used for unsat-core tracking and may be nullptr.
+    // Memberships accumulate until check() consumes them.
+    void add(expr* term, expr* regex, u_dependency* d);
+
+    // Decide the CONJUNCTION of all memberships asserted via add() jointly: a variable
     // shared across memberships is constrained consistently (the DNFs are multiplied and
     // each variable's constraints intersected).  This is the natural extension of single-
     // membership solving to a Boolean combination of memberships (a disjunction is the
     // union of DNFs; a negated membership  ~(t in R)  is just  t in complement(R)).
-    // Per-variable extra constraints are expressed here as extra memberships (v in R').
-    // l_true = sat, l_false = unsat, l_undef = gave up.
-    lbool solve_and(vector<std::pair<expr*, expr*>> const& mems);
+    // Per-variable extra constraints are expressed as extra memberships (v in R').
+    // Consumes the asserted memberships.  l_true = sat (empty conjunction is sat),
+    // l_false = unsat, l_undef = gave up.
+    lbool check();
 };