merge

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

src/smt/asserted_formulas.cpp

@@ -76,7 +76,7 @@ asserted_formulas::asserted_formulas(ast_manager & m, smt_params & p):
 void asserted_formulas::setup() {
     switch (m_params.m_lift_ite) {
     case LI_FULL:
-        m_params.m_ng_lift_ite = LI_NONE; 
+        m_params.m_ng_lift_ite = LI_NONE;
         break;
     case LI_CONSERVATIVE:
         if (m_params.m_ng_lift_ite == LI_CONSERVATIVE)
@@ -85,7 +85,7 @@ void asserted_formulas::setup() {
     default:
         break;
     }
- 
+
     if (m_params.m_relevancy_lvl == 0)
         m_params.m_relevancy_lemma = false;
 }
@@ -98,7 +98,7 @@ void asserted_formulas::setup_simplifier_plugins(simplifier & s, basic_simplifie
     s.register_plugin(alloc(array_simplifier_plugin, m, *bsimp, s, m_params));
     bvsimp = alloc(bv_simplifier_plugin, m, *bsimp, m_params);
     s.register_plugin(bvsimp);
-    s.register_plugin(alloc(datatype_simplifier_plugin, m, *bsimp));    
+    s.register_plugin(alloc(datatype_simplifier_plugin, m, *bsimp));
     s.register_plugin(alloc(fpa_simplifier_plugin, m, *bsimp));
     s.register_plugin(alloc(seq_simplifier_plugin, m, *bsimp));
 }
@@ -141,7 +141,7 @@ void asserted_formulas::set_eliminate_and(bool flag) {
 
 
 void asserted_formulas::assert_expr(expr * e, proof * _in_pr) {
-    if (inconsistent()) 
+    if (inconsistent())
         return;
     m_has_quantifiers |= ::has_quantifiers(e);
     if (!m_params.m_preprocess) {
@@ -177,7 +177,7 @@ void asserted_formulas::assert_expr(expr * e, proof * _in_pr) {
 }
 
 void asserted_formulas::assert_expr(expr * e) {
-    if (inconsistent()) 
+    if (inconsistent())
         return;
     assert_expr(e, m.mk_asserted(e));
 }
@@ -199,7 +199,7 @@ void asserted_formulas::push_scope() {
     m_bv_sharing.push_scope();
     commit();
 }
- 
+
 void asserted_formulas::pop_scope(unsigned num_scopes) {
     TRACE("asserted_formulas_scopes", tout << "before pop " << num_scopes << "\n"; display(tout););
     m_bv_sharing.pop_scope(num_scopes);
@@ -230,15 +230,15 @@ void asserted_formulas::reset() {
 
 #ifdef Z3DEBUG
 bool asserted_formulas::check_well_sorted() const {
-    for (unsigned i = 0; i < m_asserted_formulas.size(); i++) { 
-        if (!is_well_sorted(m, m_asserted_formulas.get(i))) return false; 
+    for (unsigned i = 0; i < m_asserted_formulas.size(); i++) {
+        if (!is_well_sorted(m, m_asserted_formulas.get(i))) return false;
     }
     return true;
 }
 #endif
 
 void asserted_formulas::reduce() {
-    if (inconsistent()) 
+    if (inconsistent())
         return;
     if (canceled()) {
         return;
@@ -255,7 +255,7 @@ void asserted_formulas::reduce() {
 
 
 #define INVOKE(COND, FUNC) if (COND) { FUNC; IF_VERBOSE(10000, verbose_stream() << "total size: " << get_total_size() << "\n";); }  TRACE("reduce_step_ll", ast_mark visited; display_ll(tout, visited);); TRACE("reduce_step", display(tout << #FUNC << " ");); CASSERT("well_sorted",check_well_sorted()); if (inconsistent() || canceled()) { TRACE("after_reduce", display(tout);); TRACE("after_reduce_ll", ast_mark visited; display_ll(tout, visited);); return;  }
-    
+
     set_eliminate_and(false); // do not eliminate and before nnf.
     INVOKE(m_params.m_propagate_booleans, propagate_booleans());
     INVOKE(m_params.m_propagate_values, propagate_values());
@@ -268,18 +268,18 @@ void asserted_formulas::reduce() {
     INVOKE(m_params.m_lift_ite != LI_NONE, lift_ite());
     INVOKE(m_params.m_eliminate_term_ite && m_params.m_lift_ite != LI_FULL, eliminate_term_ite());
     INVOKE(m_params.m_refine_inj_axiom && has_quantifiers(), refine_inj_axiom());
-    INVOKE(m_params.m_distribute_forall && has_quantifiers(), apply_distribute_forall());    
-    TRACE("qbv_bug", tout << "after distribute_forall:\n"; display(tout););    
+    INVOKE(m_params.m_distribute_forall && has_quantifiers(), apply_distribute_forall());
+    TRACE("qbv_bug", tout << "after distribute_forall:\n"; display(tout););
     INVOKE(m_params.m_macro_finder && has_quantifiers(), find_macros());
-    INVOKE(m_params.m_quasi_macros && has_quantifiers(), apply_quasi_macros());    
+    INVOKE(m_params.m_quasi_macros && has_quantifiers(), apply_quasi_macros());
     INVOKE(m_params.m_simplify_bit2int, apply_bit2int());
     INVOKE(m_params.m_eliminate_bounds && has_quantifiers(), cheap_quant_fourier_motzkin());
     INVOKE(m_params.m_ematching && has_quantifiers(), infer_patterns());
     INVOKE(m_params.m_max_bv_sharing && has_bv(), max_bv_sharing());
     INVOKE(m_params.m_bb_quantifiers, elim_bvs_from_quantifiers());
-    // temporary HACK: make sure that arith & bv are list-assoc 
+    // temporary HACK: make sure that arith & bv are list-assoc
     // this may destroy some simplification steps such as max_bv_sharing
-    reduce_asserted_formulas(); 
+    reduce_asserted_formulas();
 
     CASSERT("well_sorted",check_well_sorted());
 
@@ -293,7 +293,7 @@ void asserted_formulas::reduce() {
 void asserted_formulas::eliminate_and() {
     IF_IVERBOSE(10, verbose_stream() << "(smt.eliminating-and)\n";);
     set_eliminate_and(true);
-    reduce_asserted_formulas();    
+    reduce_asserted_formulas();
     TRACE("after_elim_and", display(tout););
 }
 
@@ -333,10 +333,10 @@ void asserted_formulas::display(std::ostream & out) const {
 void asserted_formulas::display_ll(std::ostream & out, ast_mark & pp_visited) const {
     if (!m_asserted_formulas.empty()) {
         unsigned sz = m_asserted_formulas.size();
-        for (unsigned i = 0; i < sz; i++) 
+        for (unsigned i = 0; i < sz; i++)
             ast_def_ll_pp(out, m, m_asserted_formulas.get(i), pp_visited, true, false);
         out << "asserted formulas:\n";
-        for (unsigned i = 0; i < sz; i++) 
+        for (unsigned i = 0; i < sz; i++)
             out << "#" << m_asserted_formulas[i]->get_id() << " ";
         out << "\n";
     }
@@ -389,8 +389,12 @@ void asserted_formulas::find_macros_core() {
     expr_ref_vector  new_exprs(m);
     proof_ref_vector new_prs(m);
     unsigned sz = m_asserted_formulas.size();
-    m_macro_finder->operator()(sz - m_asserted_qhead, m_asserted_formulas.c_ptr() + m_asserted_qhead, 
-                               m_asserted_formula_prs.c_ptr() + m_asserted_qhead, new_exprs, new_prs);
+    expr_dependency_ref_vector new_deps(m);
+    m_macro_finder->operator()(sz - m_asserted_qhead,
+                               m_asserted_formulas.c_ptr() + m_asserted_qhead,
+                               m_asserted_formula_prs.c_ptr() + m_asserted_qhead,
+                               0, // 0 == No dependency tracking
+                               new_exprs, new_prs, new_deps);
     swap_asserted_formulas(new_exprs, new_prs);
     reduce_and_solve();
 }
@@ -412,14 +416,17 @@ void asserted_formulas::apply_quasi_macros() {
     TRACE("before_quasi_macros", display(tout););
     expr_ref_vector  new_exprs(m);
     proof_ref_vector new_prs(m);      
+    expr_dependency_ref_vector new_deps(m);
     quasi_macros proc(m, m_macro_manager);    
     while (proc(m_asserted_formulas.size() - m_asserted_qhead, 
                 m_asserted_formulas.c_ptr() + m_asserted_qhead, 
                 m_asserted_formula_prs.c_ptr() + m_asserted_qhead,
-                new_exprs, new_prs)) {
+                0, // 0 == No dependency tracking
+                new_exprs, new_prs, new_deps)) {
         swap_asserted_formulas(new_exprs, new_prs);
         new_exprs.reset();
         new_prs.reset();
+        new_deps.reset();
     }
     TRACE("after_quasi_macros", display(tout););
     reduce_and_solve();
@@ -432,7 +439,7 @@ void asserted_formulas::nnf_cnf() {
     proof_ref_vector new_prs(m);
     expr_ref_vector  push_todo(m);
     proof_ref_vector push_todo_prs(m);
-    
+
     unsigned i  = m_asserted_qhead;
     unsigned sz = m_asserted_formulas.size();
     TRACE("nnf_bug", tout << "i: " << i << " sz: " << sz << "\n";);
@@ -462,8 +469,8 @@ void asserted_formulas::nnf_cnf() {
             CASSERT("well_sorted",is_well_sorted(m, r1));
             if (canceled()) {
                 return;
-            }        
-            
+            }
+
             if (m.proofs_enabled())
                 pr = m.mk_modus_ponens(push_todo_prs.get(k), pr1);
             else
@@ -600,7 +607,7 @@ void asserted_formulas::propagate_values() {
     // C is a set which contains formulas of the form
     // { x = n }, where x is a variable and n a numeral.
     // R contains the rest.
-    // 
+    //
     // - new_exprs1 is the set C
     // - new_exprs2 is the set R
     //
@@ -665,7 +672,7 @@ void asserted_formulas::propagate_values() {
         // x->n will be removed from m_cache. If we don't do that, the next transformation
         // may simplify constraints in C using these entries, and the variables x in C
         // will be (silently) eliminated, and models produced by Z3 will not contain them.
-        flush_cache(); 
+        flush_cache();
     }
     TRACE("propagate_values", tout << "after:\n"; display(tout););
 }
@@ -788,7 +795,7 @@ void asserted_formulas::refine_inj_axiom() {
             TRACE("inj_axiom", tout << "simplifying...\n" << mk_pp(n, m) << "\n" << mk_pp(new_n, m) << "\n";);
             m_asserted_formulas.set(i, new_n);
             if (m.proofs_enabled()) {
-                proof_ref new_pr(m);     
+                proof_ref new_pr(m);
                 new_pr = m.mk_rewrite(n, new_n);
                 new_pr = m.mk_modus_ponens(pr, new_pr);
                 m_asserted_formula_prs.set(i, new_pr);
@@ -862,7 +869,7 @@ void asserted_formulas::max_bv_sharing() {
     }
     reduce_asserted_formulas();
     TRACE("bv_sharing", display(tout););
-    
+
 }
 
 #ifdef Z3DEBUG

src/smt/asserted_formulas.h

@@ -51,7 +51,7 @@ class asserted_formulas {
 
     macro_manager               m_macro_manager;
     scoped_ptr<macro_finder>    m_macro_finder;
-    
+
     bit2int                     m_bit2int;
 
     maximise_bv_sharing         m_bv_sharing;
@@ -90,7 +90,7 @@ class asserted_formulas {
     bool apply_bit2int();
     void lift_ite();
     bool elim_bvs_from_quantifiers();
-    void ng_lift_ite(); 
+    void ng_lift_ite();
 #ifdef Z3DEBUG
     bool check_well_sorted() const;
 #endif
@@ -115,8 +115,8 @@ public:
     unsigned get_num_formulas() const { return m_asserted_formulas.size(); }
     unsigned get_formulas_last_level() const;
     unsigned get_qhead() const { return m_asserted_qhead; }
-    void commit(); 
-    void commit(unsigned new_qhead); 
+    void commit();
+    void commit(unsigned new_qhead);
     expr * get_formula(unsigned idx) const { return m_asserted_formulas.get(idx); }
     proof * get_formula_proof(unsigned idx) const { return m.proofs_enabled() ? m_asserted_formula_prs.get(idx) : 0; }
     expr * const * get_formulas() const { return m_asserted_formulas.c_ptr(); }
@@ -133,7 +133,7 @@ public:
     void collect_statistics(statistics & st) const;
     // TODO: improve precision of the following method.
     bool has_quantifiers() const { return m_has_quantifiers; }
-    
+
     // -----------------------------------
     //
     // Macros
@@ -144,9 +144,7 @@ public:
     func_decl * get_macro_func_decl(unsigned i) const { return m_macro_manager.get_macro_func_decl(i); }
     func_decl * get_macro_interpretation(unsigned i, expr_ref & interp) const { return m_macro_manager.get_macro_interpretation(i, interp); }
     quantifier * get_macro_quantifier(func_decl * f) const { return m_macro_manager.get_macro_quantifier(f); }
-    // auxiliary function used to create a logic context based on a model.
-    void insert_macro(func_decl * f, quantifier * m, proof * pr) { m_macro_manager.insert(f, m, pr); }
-
+    void insert_macro(func_decl * f, quantifier * m, proof * pr, expr_dependency * dep) { m_macro_manager.insert(f, m, pr, dep); }
 };
 
 #endif /* ASSERTED_FORMULAS_H_ */

src/smt/params/preprocessor_params.cpp

@@ -22,6 +22,8 @@ Revision History:
 void preprocessor_params::updt_local_params(params_ref const & _p) {
     smt_params_helper p(_p);
     m_macro_finder            = p.macro_finder();
+    m_quasi_macros            = p.quasi_macros();
+    m_restricted_quasi_macros = p.restricted_quasi_macros();
     m_pull_nested_quantifiers = p.pull_nested_quantifiers();
     m_refine_inj_axiom        = p.refine_inj_axioms();
 }

src/smt/params/smt_params_helper.pyg

@@ -7,6 +7,8 @@ def_module_params(module_name='smt',
                           ('random_seed', UINT, 0, 'random seed for the smt solver'),
                           ('relevancy', UINT, 2, 'relevancy propagation heuristic: 0 - disabled, 1 - relevancy is tracked by only affects quantifier instantiation, 2 - relevancy is tracked, and an atom is only asserted if it is relevant'),
                           ('macro_finder', BOOL, False, 'try to find universally quantified formulas that can be viewed as macros'),
+                          ('quasi_macros', BOOL, False, 'try to find universally quantified formulas that are quasi-macros'),
+                          ('restricted_quasi_macros', BOOL, False, 'try to find universally quantified formulas that are restricted quasi-macros'),
                           ('ematching', BOOL, True, 'E-Matching based quantifier instantiation'),
                           ('phase_selection', UINT, 3, 'phase selection heuristic: 0 - always false, 1 - always true, 2 - phase caching, 3 - phase caching conservative, 4 - phase caching conservative 2, 5 - random, 6 - number of occurrences'),
                           ('restart_strategy', UINT, 1, '0 - geometric, 1 - inner-outer-geometric, 2 - luby, 3 - fixed, 4 - arithmetic'),

src/smt/smt_context.h

@@ -209,7 +209,7 @@ namespace smt {
             ~scoped_mk_model() {
                 if (m_ctx.m_proto_model.get() != 0) {
                     m_ctx.m_model = m_ctx.m_proto_model->mk_model();
-                    m_ctx.add_rec_funs_to_model();            
+                    m_ctx.add_rec_funs_to_model();
                     m_ctx.m_proto_model = 0; // proto_model is not needed anymore.
                 }
             }
@@ -1566,7 +1566,7 @@ namespace smt {
         func_decl * get_macro_func_decl(unsigned i) const { return m_asserted_formulas.get_macro_func_decl(i); }
         func_decl * get_macro_interpretation(unsigned i, expr_ref & interp) const { return m_asserted_formulas.get_macro_interpretation(i, interp); }
         quantifier * get_macro_quantifier(func_decl * f) const { return m_asserted_formulas.get_macro_quantifier(f); }
-        void insert_macro(func_decl * f, quantifier * m, proof * pr) { m_asserted_formulas.insert_macro(f, m, pr); }
+        void insert_macro(func_decl * f, quantifier * m, proof * pr, expr_dependency * dep) { m_asserted_formulas.insert_macro(f, m, pr, dep); }
     };
 
 };