drat

Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com>

src/sat/smt/array_internalize.cpp

@@ -247,6 +247,14 @@ namespace array {
         return false;
     }
 
+    bool solver::is_beta_redex(euf::enode* p, euf::enode* n) const {
+        if (a.is_select(p->get_expr()))
+            return p->get_arg(0)->get_root() == n->get_root();
+        if (a.is_map(p->get_expr()))
+            return true;
+        return false;
+    }
+
     func_decl_ref_vector const& solver::sort2diff(sort* s) {
         func_decl_ref_vector* result = nullptr;
         if (m_sort2diff.find(s, result))

src/sat/smt/array_solver.h

@@ -299,6 +299,7 @@ namespace array {
         euf::theory_var mk_var(euf::enode* n) override;
         void apply_sort_cnstr(euf::enode* n, sort* s) override;
         bool is_shared(theory_var v) const override;
+        bool is_beta_redex(euf::enode* p, euf::enode* n) const override;
         bool enable_self_propagate() const override { return true; }
         void relevant_eh(euf::enode* n) override;
         bool enable_ackerman_axioms(euf::enode* n) const override { return !a.is_array(n->get_sort()); }

src/sat/smt/euf_internalize.cpp

@@ -358,6 +358,7 @@ namespace euf {
         for (auto const& p : euf::enode_th_vars(n)) {
             family_id id = p.get_id();
             if (m.get_basic_family_id() != id) {
+                
                 if (th_id != m.get_basic_family_id())
                     return true;
                 th_id = id;               
@@ -369,6 +370,8 @@ namespace euf {
         for (enode* parent : euf::enode_parents(n)) {
             app* p = to_app(parent->get_expr());
             family_id fid = p->get_family_id();
+            if (is_beta_redex(parent, n))
+                continue;
             if (fid != th_id && fid != m.get_basic_family_id())
                 return true;
         }
@@ -407,6 +410,13 @@ namespace euf {
         return false;
     }
 
+    bool solver::is_beta_redex(enode* p, enode* n) const {
+        for (auto const& th : enode_th_vars(p))
+            if (fid2solver(th.get_id())->is_beta_redex(p, n))
+                return true;
+        return false;
+    }
+
     expr_ref solver::mk_eq(expr* e1, expr* e2) {
         expr_ref _e1(e1, m);
         expr_ref _e2(e2, m);

src/sat/smt/euf_solver.h

@@ -371,6 +371,7 @@ namespace euf {
         th_rewriter& get_rewriter() { return m_rewriter; }
         void rewrite(expr_ref& e) { m_rewriter(e); }
         bool is_shared(euf::enode* n) const;
+        bool is_beta_redex(euf::enode* p, euf::enode* n) const;
         bool enable_ackerman_axioms(expr* n) const;
         bool is_fixed(euf::enode* n, expr_ref& val, sat::literal_vector& explain);
 

src/sat/smt/sat_th.h

@@ -127,6 +127,13 @@ namespace euf {
         */
         virtual bool is_shared(theory_var v) const { return false; }
 
+
+        /**
+           \brief Determine if argument n of parent p is a beta redex position
+         */
+
+        virtual bool is_beta_redex(euf::enode* p, euf::enode* n) const { return false; }
+
         sat::status status() const { return sat::status::th(m_is_redundant, get_id()); }
 
     };