move functionality from qe_util to ast_util

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

src/ast/ast_util.cpp

@@ -191,3 +191,116 @@ expr * expand_distinct(ast_manager & m, unsigned num_args, expr * const * args)
     }
     return mk_and(m, new_diseqs.size(), new_diseqs.c_ptr());
 }
+
+void flatten_and(expr_ref_vector& result) {
+    ast_manager& m = result.get_manager();
+    expr* e1, *e2, *e3;
+    for (unsigned i = 0; i < result.size(); ++i) {
+        if (m.is_and(result[i].get())) {
+            app* a = to_app(result[i].get());
+            unsigned num_args = a->get_num_args();
+            for (unsigned j = 0; j < num_args; ++j) {
+                result.push_back(a->get_arg(j));
+            }
+            result[i] = result.back();
+            result.pop_back();
+            --i;
+        }
+        else if (m.is_not(result[i].get(), e1) && m.is_not(e1, e2)) {
+            result[i] = e2;
+            --i;
+        }
+        else if (m.is_not(result[i].get(), e1) && m.is_or(e1)) {
+            app* a = to_app(e1);
+            unsigned num_args = a->get_num_args();
+            for (unsigned j = 0; j < num_args; ++j) {
+                result.push_back(m.mk_not(a->get_arg(j)));
+            }
+            result[i] = result.back();
+            result.pop_back();
+            --i;                
+        }
+        else if (m.is_not(result[i].get(), e1) && m.is_implies(e1,e2,e3)) {
+            result.push_back(e2);
+            result[i] = m.mk_not(e3);
+            --i;
+        }
+        else if (m.is_true(result[i].get()) ||
+                 (m.is_not(result[i].get(), e1) &&
+                  m.is_false(e1))) {
+            result[i] = result.back();
+            result.pop_back();
+            --i;                
+        }
+        else if (m.is_false(result[i].get()) ||
+                 (m.is_not(result[i].get(), e1) &&
+                  m.is_true(e1))) {
+            result.reset();
+            result.push_back(m.mk_false());
+            return;
+        }
+    }
+}
+
+void flatten_and(expr* fml, expr_ref_vector& result) {
+    SASSERT(result.get_manager().is_bool(fml));
+    result.push_back(fml);        
+    flatten_and(result);
+}
+
+void flatten_or(expr_ref_vector& result) {
+    ast_manager& m = result.get_manager();
+    expr* e1, *e2, *e3;
+    for (unsigned i = 0; i < result.size(); ++i) {
+        if (m.is_or(result[i].get())) {
+            app* a = to_app(result[i].get());
+            unsigned num_args = a->get_num_args();
+            for (unsigned j = 0; j < num_args; ++j) {
+                result.push_back(a->get_arg(j));
+            }
+            result[i] = result.back();
+            result.pop_back();
+            --i;
+        }
+        else if (m.is_not(result[i].get(), e1) && m.is_not(e1, e2)) {
+            result[i] = e2;
+            --i;
+        }
+        else if (m.is_not(result[i].get(), e1) && m.is_and(e1)) {
+            app* a = to_app(e1);
+            unsigned num_args = a->get_num_args();
+            for (unsigned j = 0; j < num_args; ++j) {
+                result.push_back(m.mk_not(a->get_arg(j)));
+            }
+            result[i] = result.back();
+            result.pop_back();
+            --i;                
+        }
+        else if (m.is_implies(result[i].get(),e2,e3)) {
+            result.push_back(e3);
+            result[i] = m.mk_not(e2);
+            --i;
+        }
+        else if (m.is_false(result[i].get()) ||
+                 (m.is_not(result[i].get(), e1) &&
+                  m.is_true(e1))) {
+            result[i] = result.back();
+            result.pop_back();
+            --i;                
+        }
+        else if (m.is_true(result[i].get()) ||
+                 (m.is_not(result[i].get(), e1) &&
+                  m.is_false(e1))) {
+            result.reset();
+            result.push_back(m.mk_true());
+            return;
+        }
+    }        
+}
+
+
+void flatten_or(expr* fml, expr_ref_vector& result) {
+    SASSERT(result.get_manager().is_bool(fml));
+    result.push_back(fml);        
+    flatten_or(result);
+}

src/ast/ast_util.h

@@ -126,5 +126,18 @@ expr * mk_not(ast_manager & m, expr * arg);
 */
 expr * expand_distinct(ast_manager & m, unsigned num_args, expr * const * args);
 
+/**
+   \brief Collect top-level conjunctions and disjunctions.
+*/
+
+void flatten_and(expr_ref_vector& result);
+
+void flatten_and(expr* fml, expr_ref_vector& result);
+
+void flatten_or(expr_ref_vector& result);
+
+void flatten_or(expr* fml, expr_ref_vector& result);
+
+
 #endif /* _AST_UTIL_H_ */
 

src/muz/base/dl_boogie_proof.cpp

@@ -55,7 +55,7 @@ Example from Boogie:
 #include "model_pp.h"
 #include "proof_utils.h"
 #include "ast_pp.h"
-#include "qe_util.h"
+#include "ast_util.h"
 
 namespace datalog {
     
@@ -97,7 +97,7 @@ namespace datalog {
                 if (!m.is_implies(premise, l1, l2)) {
                     continue;
                 }
-                qe::flatten_and(l1, literals);
+                flatten_and(l1, literals);
                 positions2.reset();
                 premises2.reset();
                 premises2.push_back(premise);       

src/muz/base/dl_rule.cpp

@@ -259,7 +259,7 @@ namespace datalog {
         if (m.is_implies(fml, e1, e2)) {
             m_args.reset();
             head = ensure_app(e2);
-            qe::flatten_and(e1, m_args);
+            flatten_and(e1, m_args);
             for (unsigned i = 0; i < m_args.size(); ++i) {
                 body.push_back(ensure_app(m_args[i].get()));
             }
@@ -378,7 +378,7 @@ namespace datalog {
         for (unsigned i = 0; i < body.size(); ++i) {
             r.push_back(body[i].get());
         }
-        qe::flatten_and(r);
+        flatten_and(r);
         body.reset();
         for (unsigned i = 0; i < r.size(); ++i) {
             body.push_back(ensure_app(r[i].get()));

src/muz/base/hnf.cpp

@@ -53,6 +53,7 @@ Notes:
 #include"cooperate.h"
 #include"ast_pp.h"
 #include"quant_hoist.h"
+#include"ast_util.h"
 #include"dl_util.h"
 #include"for_each_ast.h"
 #include"for_each_expr.h"
@@ -247,7 +248,7 @@ private:
             m_body.push_back(e1);
             head = e2;
         }
-        qe::flatten_and(m_body);
+        flatten_and(m_body);
         if (premise) {
             p = m.mk_rewrite(fml0, mk_implies(m_body, head));
         }

src/muz/fp/horn_tactic.cpp

@@ -28,6 +28,7 @@ Revision History:
 #include"filter_model_converter.h"
 #include"dl_transforms.h"
 #include"fixedpoint_params.hpp"
+#include"ast_util.h"
 
 class horn_tactic : public tactic {
     struct imp {
@@ -145,7 +146,7 @@ class horn_tactic : public tactic {
             expr_ref_vector args(m), body(m);
             expr_ref head(m);
             expr* a = 0, *a1 = 0;
-            qe::flatten_or(tmp, args);
+            flatten_or(tmp, args);
             for (unsigned i = 0; i < args.size(); ++i) {
                 a = args[i].get(); 
                 check_predicate(mark, a);

src/muz/pdr/pdr_closure.cpp

@@ -143,7 +143,7 @@ namespace pdr {
 
     expr_ref closure::close_conjunction(expr* fml) {
         expr_ref_vector fmls(m);
-        qe::flatten_and(fml, fmls);
+        flatten_and(fml, fmls);
         for (unsigned i = 0; i < fmls.size(); ++i) {
             fmls[i] = close_fml(fmls[i].get());            
         }

src/muz/pdr/pdr_context.cpp

@@ -349,7 +349,7 @@ namespace pdr {
 
     void pred_transformer::add_property(expr* lemma, unsigned lvl) {
         expr_ref_vector lemmas(m);
-        qe::flatten_and(lemma, lemmas);
+        flatten_and(lemma, lemmas);
         for (unsigned i = 0; i < lemmas.size(); ++i) {
             expr* lemma_i = lemmas[i].get();
             if (add_property1(lemma_i, lvl)) {
@@ -594,7 +594,7 @@ namespace pdr {
         for (unsigned i = ut_size; i < t_size; ++i) {
             tail.push_back(rule.get_tail(i));
         }        
-        qe::flatten_and(tail);
+        flatten_and(tail);
         for (unsigned i = 0; i < tail.size(); ++i) {
             expr_ref tmp(m);
             var_subst(m, false)(tail[i].get(), var_reprs.size(), (expr*const*)var_reprs.c_ptr(), tmp);
@@ -809,7 +809,7 @@ namespace pdr {
         ast_manager& m = pt().get_manager();
         expr_ref_vector conjs(m);
         obj_map<expr,expr*> model;
-        qe::flatten_and(state(), conjs);
+        flatten_and(state(), conjs);
         for (unsigned i = 0; i < conjs.size(); ++i) {
             expr* e = conjs[i].get(), *e1, *e2;
             if (m.is_eq(e, e1, e2) || m.is_iff(e, e1, e2)) {
@@ -2176,7 +2176,7 @@ namespace pdr {
         expr_ref_vector mdl(m), forms(m), Phi(m);
         forms.push_back(T);
         forms.push_back(phi);
-        qe::flatten_and(forms);        
+        flatten_and(forms);        
         ptr_vector<expr> forms1(forms.size(), forms.c_ptr());
         if (use_model_generalizer) {
             Phi.append(mev.minimize_model(forms1, M));
@@ -2232,7 +2232,7 @@ namespace pdr {
             TRACE("pdr", tout << "Projected:\n" << mk_pp(phi1, m) << "\n";);
         }
         Phi.reset();
-        qe::flatten_and(phi1, Phi);
+        flatten_and(phi1, Phi);
         unsigned_vector indices;
         vector<expr_ref_vector> child_states;
         child_states.resize(preds.size(), expr_ref_vector(m));

src/muz/pdr/pdr_farkas_learner.cpp

@@ -449,7 +449,7 @@ namespace pdr {
 
         expr_set bs;
         expr_ref_vector blist(m_pr);
-        qe::flatten_and(B, blist);
+        flatten_and(B, blist);
         for (unsigned i = 0; i < blist.size(); ++i) {
             bs.insert(blist[i].get());
         }

src/muz/pdr/pdr_generalizers.cpp

@@ -119,7 +119,7 @@ namespace pdr {
         if (core.empty()) return;
         expr_ref A(m), B(qe::mk_and(core)), C(m);
         expr_ref_vector Bs(m);
-        qe::flatten_or(B, Bs);
+        flatten_or(B, Bs);
         A = n.pt().get_propagation_formula(m_ctx.get_pred_transformers(), n.level());
 
         bool change = false;
@@ -138,7 +138,7 @@ namespace pdr {
             C = qe::mk_or(Bs);
             TRACE("pdr", tout << "prop:\n" << mk_pp(A,m) << "\ngen:" << mk_pp(B, m) << "\nto: " << mk_pp(C, m) << "\n";);
             core.reset();
-            qe::flatten_and(C, core);    
+            flatten_and(C, core);    
             uses_level = true;
         }    
     }
@@ -190,7 +190,7 @@ namespace pdr {
         expr_ref fml2 = n.pt().get_formulas(n.level(), false);
         fml1_2.push_back(fml1);
         fml1_2.push_back(0);
-        qe::flatten_and(fml2, fmls);
+        flatten_and(fml2, fmls);
         for (unsigned i = 0; i < fmls.size(); ++i) {
             fml2 = m.mk_not(fmls[i].get());
             fml1_2[1] = fml2;

src/muz/pdr/pdr_manager.cpp

@@ -56,7 +56,7 @@ namespace pdr {
 
     expr_ref inductive_property::fixup_clause(expr* fml) const {        
         expr_ref_vector disjs(m);
-        qe::flatten_or(fml, disjs);
+        flatten_or(fml, disjs);
         expr_ref result(m);
         bool_rewriter(m).mk_or(disjs.size(), disjs.c_ptr(), result);
         return result;
@@ -65,7 +65,7 @@ namespace pdr {
     expr_ref inductive_property::fixup_clauses(expr* fml) const {
         expr_ref_vector conjs(m);
         expr_ref result(m);
-        qe::flatten_and(fml, conjs);
+        flatten_and(fml, conjs);
         for (unsigned i = 0; i < conjs.size(); ++i) {
             conjs[i] = fixup_clause(conjs[i].get());
         }
@@ -237,7 +237,7 @@ namespace pdr {
     expr_ref manager::mk_not_and(expr_ref_vector const& conjs) {
         expr_ref result(m), e(m);
         expr_ref_vector es(conjs);
-        qe::flatten_and(es);
+        flatten_and(es);
         for (unsigned i = 0; i < es.size(); ++i) {
             m_brwr.mk_not(es[i].get(), e);
             es[i] = e;

src/muz/pdr/pdr_prop_solver.cpp

@@ -76,7 +76,7 @@ namespace pdr {
         }
 
         void mk_safe(expr_ref_vector& conjs) {
-            qe::flatten_and(conjs);
+            flatten_and(conjs);
             expand_literals(conjs);
             for (unsigned i = 0; i < conjs.size(); ++i) {
                 expr * lit = conjs[i].get();

src/muz/pdr/pdr_util.cpp

@@ -93,7 +93,7 @@ namespace pdr {
     void reduce_disequalities(model& model, unsigned threshold, expr_ref& fml) {
         ast_manager& m = fml.get_manager();
         expr_ref_vector conjs(m);
-        qe::flatten_and(fml, conjs);
+        flatten_and(fml, conjs);
         obj_map<expr, unsigned> diseqs;
         expr* n, *lhs, *rhs;
         for (unsigned i = 0; i < conjs.size(); ++i) {

src/muz/rel/karr_relation.cpp

@@ -6,6 +6,7 @@ Copyright (c) 2015 Microsoft Corporation
 
 #include "karr_relation.h"
 #include "bool_rewriter.h"
+#include "ast_util.h"
 
 namespace datalog {
     class karr_relation : public relation_base {              
@@ -114,7 +115,7 @@ namespace datalog {
             var* v, *w;
             rational n1, n2;
             expr_ref_vector conjs(m);
-            qe::flatten_and(cond, conjs);
+            flatten_and(cond, conjs);
             matrix& M = get_ineqs();
             unsigned num_columns = get_signature().size();
 

src/muz/rel/udoc_relation.cpp

@@ -648,7 +648,7 @@ namespace datalog {
         ast_manager& m = get_plugin().get_ast_manager();
         expr_ref_vector conds(m), guards(m), rests(m);
         conds.push_back(cond);
-        qe::flatten_and(conds);
+        flatten_and(conds);
         for (unsigned i = 0; i < conds.size(); ++i) {
             expr* g = conds[i].get();
             if (is_guard(g)) {
@@ -667,7 +667,7 @@ namespace datalog {
         ast_manager& m = get_plugin().get_ast_manager();
         expr_ref_vector conds(m);
         conds.push_back(g);
-        qe::flatten_and(conds);
+        flatten_and(conds);
         expr* e1, *e2;
         for (unsigned i = 0; i < conds.size(); ++i) {
             expr* g = conds[i].get();

src/muz/tab/tab_context.cpp

@@ -31,6 +31,7 @@ Revision History:
 #include "matcher.h"
 #include "scoped_proof.h"
 #include "fixedpoint_params.hpp"
+#include "ast_util.h"
 
 namespace tb {
 
@@ -210,7 +211,7 @@ namespace tb {
                 fmls.push_back(m_predicates[i]);
             }
             fmls.push_back(m_constraint);
-            qe::flatten_and(fmls);
+            flatten_and(fmls);
             bool_rewriter(m).mk_and(fmls.size(), fmls.c_ptr(), fml);
             return fml;
         }
@@ -341,7 +342,7 @@ namespace tb {
             expr_ref tmp(m);
             substitution subst(m);
             subst.reserve(1, get_num_vars());
-            qe::flatten_and(m_constraint, fmls);
+            flatten_and(m_constraint, fmls);
             unsigned num_fmls = fmls.size();
             for (unsigned i = 0; i < num_fmls; ++i) {
                 if (get_subst(rw, subst, i, fmls)) {
@@ -668,7 +669,7 @@ namespace tb {
 
 
             m_qe(m_empty_set, false, fmls);
-            qe::flatten_and(fmls);
+            flatten_and(fmls);
             for (unsigned i = 0; i < fmls.size(); ++i) {
                 expr_ref n = normalize(fmls[i].get());
                 if (m_sat_lits.contains(n)) {

src/muz/transforms/dl_mk_array_blast.cpp

@@ -18,9 +18,10 @@ Revision History:
 --*/
 
 #include "dl_mk_array_blast.h"
-#include "qe_util.h"
+#include "ast_util.h"
 #include "scoped_proof.h"
 
+
 namespace datalog {
 
 
@@ -115,7 +116,7 @@ namespace datalog {
     
     bool mk_array_blast::ackermanize(rule const& r, expr_ref& body, expr_ref& head) {
         expr_ref_vector conjs(m), trail(m);
-        qe::flatten_and(body, conjs);
+        flatten_and(body, conjs);
         m_defs.reset();
         m_next_var = 0;
         ptr_vector<expr> todo;
@@ -246,7 +247,7 @@ namespace datalog {
         for (unsigned i = utsz; i < tsz; ++i) {
             conjs.push_back(r.get_tail(i));
         }
-        qe::flatten_and(conjs);
+        flatten_and(conjs);
         for (unsigned i = 0; i < conjs.size(); ++i) {
             expr* x, *y, *e = conjs[i].get();
             

src/muz/transforms/dl_mk_interp_tail_simplifier.cpp

@@ -25,6 +25,7 @@ Revision History:
 #include"rewriter_def.h"
 #include"dl_mk_rule_inliner.h"
 #include"dl_mk_interp_tail_simplifier.h"
+#include"ast_util.h"
 
 namespace datalog {
 
@@ -547,7 +548,7 @@ namespace datalog {
 
         if (modified) {
             m_conj.reset();
-            qe::flatten_and(simp_res, m_conj);
+            flatten_and(simp_res, m_conj);
             for (unsigned i = 0; i < m_conj.size(); ++i) {
                 expr* e = m_conj[i].get();
                 if (is_app(e)) {

src/muz/transforms/dl_mk_quantifier_instantiation.cpp

@@ -49,7 +49,7 @@ namespace datalog {
         for (unsigned j = 0; j < tsz; ++j) {
             conjs.push_back(r.get_tail(j));            
         }
-        qe::flatten_and(conjs);
+        flatten_and(conjs);
         for (unsigned j = 0; j < conjs.size(); ++j) {
             expr* e = conjs[j].get();
             quantifier* q;

src/muz/transforms/dl_mk_slice.cpp

@@ -52,6 +52,7 @@ Revision History:
 
 #include "dl_mk_slice.h"
 #include "ast_pp.h"
+#include "ast_util.h"
 #include "expr_functors.h"
 #include "dl_mk_rule_inliner.h"
 #include "model_smt2_pp.h"
@@ -619,7 +620,7 @@ namespace datalog {
         for (unsigned j = r.get_uninterpreted_tail_size(); j < r.get_tail_size(); ++j) {
             conjs.push_back(r.get_tail(j));
         }
-        qe::flatten_and(conjs);
+        flatten_and(conjs);
         return conjs;
     }
 

src/qe/qe.cpp

@@ -81,7 +81,7 @@ namespace qe {
             ptr_vector<expr> todo;
             ptr_vector<expr> conjs_closed, conjs_mixed, conjs_open;
             
-            qe::flatten_and(fml, conjs);
+            flatten_and(fml, conjs);
 
             for (unsigned i = 0; i < conjs.size(); ++i) {
                 todo.push_back(conjs[i].get());
@@ -306,7 +306,7 @@ namespace qe {
     // conj_enum
 
     conj_enum::conj_enum(ast_manager& m, expr* e): m(m), m_conjs(m) {
-        qe::flatten_and(e, m_conjs);
+        flatten_and(e, m_conjs);
     }
 
     void conj_enum::extract_equalities(expr_ref_vector& eqs) {

src/qe/qe_arith.cpp

@@ -20,6 +20,7 @@ Revision History:
 
 #include "qe_arith.h"
 #include "qe_util.h"
+#include "ast_util.h"
 #include "arith_decl_plugin.h"
 #include "ast_pp.h"
 #include "th_rewriter.h"
@@ -299,7 +300,7 @@ namespace qe {
         ast_manager& m = vars.get_manager();
         arith_project_util ap(m);
         expr_ref_vector lits(m);
-        qe::flatten_and(fml, lits);
+        flatten_and(fml, lits);
         return ap(model, vars, lits);
     }
 

src/qe/qe_lite.cpp

@@ -30,6 +30,7 @@ Revision History:
 #include "bool_rewriter.h"
 #include "var_subst.h"
 #include "uint_set.h"
+#include "ast_util.h"
 #include "qe_util.h"
 #include "th_rewriter.h"
 #include "for_each_expr.h"
@@ -723,7 +724,7 @@ namespace eq {
                     m_subst(r, m_subst_map.size(), m_subst_map.c_ptr(), new_r);
                     m_rewriter(new_r);
                     conjs.reset();
-                    qe::flatten_and(new_r, conjs);
+                    flatten_and(new_r, conjs);
                     reduced = true;
                 }
             }
@@ -2414,7 +2415,7 @@ public:
 
     void operator()(uint_set const& index_set, bool index_of_bound, expr_ref& fml) {
         expr_ref_vector disjs(m);
-        qe::flatten_or(fml, disjs);
+        flatten_or(fml, disjs);
         for (unsigned i = 0; i < disjs.size(); ++i) {
             expr_ref_vector conjs(m);
             conjs.push_back(disjs[i].get());
@@ -2427,7 +2428,7 @@ public:
 
 
     void operator()(uint_set const& index_set, bool index_of_bound, expr_ref_vector& fmls) {
-        qe::flatten_and(fmls);
+        flatten_and(fmls);
         unsigned index;
         if (has_unique_non_ground(fmls, index)) {
             expr_ref fml(m);

src/qe/qe_util.cpp

@@ -8,118 +8,6 @@ Copyright (c) 2015 Microsoft Corporation
 #include "bool_rewriter.h"
 
 namespace qe {
-    void flatten_and(expr_ref_vector& result) {
-        ast_manager& m = result.get_manager();
-        expr* e1, *e2, *e3;
-        for (unsigned i = 0; i < result.size(); ++i) {
-            if (m.is_and(result[i].get())) {
-                app* a = to_app(result[i].get());
-                unsigned num_args = a->get_num_args();
-                for (unsigned j = 0; j < num_args; ++j) {
-                    result.push_back(a->get_arg(j));
-                }
-                result[i] = result.back();
-                result.pop_back();
-                --i;
-            }
-            else if (m.is_not(result[i].get(), e1) && m.is_not(e1, e2)) {
-                result[i] = e2;
-                --i;
-            }
-            else if (m.is_not(result[i].get(), e1) && m.is_or(e1)) {
-                app* a = to_app(e1);
-                unsigned num_args = a->get_num_args();
-                for (unsigned j = 0; j < num_args; ++j) {
-                    result.push_back(m.mk_not(a->get_arg(j)));
-                }
-                result[i] = result.back();
-                result.pop_back();
-                --i;                
-            }
-            else if (m.is_not(result[i].get(), e1) && m.is_implies(e1,e2,e3)) {
-                result.push_back(e2);
-                result[i] = m.mk_not(e3);
-                --i;
-            }
-            else if (m.is_true(result[i].get()) ||
-                     (m.is_not(result[i].get(), e1) &&
-                      m.is_false(e1))) {
-                result[i] = result.back();
-                result.pop_back();
-                --i;                
-            }
-            else if (m.is_false(result[i].get()) ||
-                     (m.is_not(result[i].get(), e1) &&
-                      m.is_true(e1))) {
-                result.reset();
-                result.push_back(m.mk_false());
-                return;
-            }
-        }
-    }
-
-    void flatten_and(expr* fml, expr_ref_vector& result) {
-        SASSERT(result.get_manager().is_bool(fml));
-        result.push_back(fml);        
-        flatten_and(result);
-    }
-
-    void flatten_or(expr_ref_vector& result) {
-        ast_manager& m = result.get_manager();
-        expr* e1, *e2, *e3;
-        for (unsigned i = 0; i < result.size(); ++i) {
-            if (m.is_or(result[i].get())) {
-                app* a = to_app(result[i].get());
-                unsigned num_args = a->get_num_args();
-                for (unsigned j = 0; j < num_args; ++j) {
-                    result.push_back(a->get_arg(j));
-                }
-                result[i] = result.back();
-                result.pop_back();
-                --i;
-            }
-            else if (m.is_not(result[i].get(), e1) && m.is_not(e1, e2)) {
-                result[i] = e2;
-                --i;
-            }
-            else if (m.is_not(result[i].get(), e1) && m.is_and(e1)) {
-                app* a = to_app(e1);
-                unsigned num_args = a->get_num_args();
-                for (unsigned j = 0; j < num_args; ++j) {
-                    result.push_back(m.mk_not(a->get_arg(j)));
-                }
-                result[i] = result.back();
-                result.pop_back();
-                --i;                
-            }
-            else if (m.is_implies(result[i].get(),e2,e3)) {
-                result.push_back(e3);
-                result[i] = m.mk_not(e2);
-                --i;
-            }
-            else if (m.is_false(result[i].get()) ||
-                     (m.is_not(result[i].get(), e1) &&
-                      m.is_true(e1))) {
-                result[i] = result.back();
-                result.pop_back();
-                --i;                
-            }
-            else if (m.is_true(result[i].get()) ||
-                     (m.is_not(result[i].get(), e1) &&
-                      m.is_false(e1))) {
-                result.reset();
-                result.push_back(m.mk_true());
-                return;
-            }
-        }        
-    }
-
-
-    void flatten_or(expr* fml, expr_ref_vector& result) {
-        SASSERT(result.get_manager().is_bool(fml));
-        result.push_back(fml);        
-        flatten_or(result);
-    }
 
     expr_ref mk_and(expr_ref_vector const& fmls) {
         ast_manager& m = fmls.get_manager();

src/qe/qe_util.h

@@ -22,16 +22,6 @@ Revision History:
 #include "ast.h"
 
 namespace qe {
-    /**
-       \brief Collect top-level conjunctions and disjunctions.
-    */
-    void flatten_and(expr_ref_vector& result);
-
-    void flatten_and(expr* fml, expr_ref_vector& result);
-
-    void flatten_or(expr_ref_vector& result);
-
-    void flatten_or(expr* fml, expr_ref_vector& result);
 
     expr_ref mk_and(expr_ref_vector const& fmls);