/*++ Copyright (c) 2011 Microsoft Corporation Module Name: sat_simplifier.h Abstract: SAT simplification procedures that use a "full" occurrence list: Subsumption, Blocked Clause Removal, Variable Elimination, ... Author: Leonardo de Moura (leonardo) 2011-05-24. Revision History: --*/ #ifndef _SAT_SIMPLIFIER_H_ #define _SAT_SIMPLIFIER_H_ #include"sat_types.h" #include"sat_clause.h" #include"sat_clause_set.h" #include"sat_clause_use_list.h" #include"sat_watched.h" #include"sat_model_converter.h" #include"heap.h" #include"statistics.h" #include"params.h" namespace sat { class solver; class use_list { vector m_use_list; public: void init(unsigned num_vars); void insert(clause & c); void erase(clause & c); void erase(clause & c, literal l); clause_use_list & get(literal l) { return m_use_list[l.index()]; } clause_use_list const & get(literal l) const { return m_use_list[l.index()]; } void finalize() { m_use_list.finalize(); } }; class simplifier { solver & s; unsigned m_num_calls; use_list m_use_list; clause_set m_sub_todo; svector m_sub_bin_todo; unsigned m_last_sub_trail_sz; // size of the trail since last cleanup bool_var_set m_elim_todo; bool m_need_cleanup; tmp_clause m_dummy; // simplifier extra variable fields. svector m_visited; // transient // counters int m_sub_counter; int m_elim_counter; // config bool m_elim_blocked_clauses; unsigned m_elim_blocked_clauses_at; unsigned m_blocked_clause_limit; bool m_resolution; unsigned m_res_limit; unsigned m_res_occ_cutoff; unsigned m_res_occ_cutoff1; unsigned m_res_occ_cutoff2; unsigned m_res_occ_cutoff3; unsigned m_res_lit_cutoff1; unsigned m_res_lit_cutoff2; unsigned m_res_lit_cutoff3; unsigned m_res_cls_cutoff1; unsigned m_res_cls_cutoff2; bool m_subsumption; unsigned m_subsumption_limit; // stats unsigned m_num_blocked_clauses; unsigned m_num_subsumed; unsigned m_num_elim_vars; unsigned m_num_sub_res; unsigned m_num_elim_lits; struct size_lt { bool operator()(clause const * c1, clause const * c2) const { return c1->size() > c2->size(); } }; void checkpoint(); void init_visited(); void mark_visited(literal l) { m_visited[l.index()] = true; } void unmark_visited(literal l) { m_visited[l.index()] = false; } bool is_marked(literal l) const { return m_visited[l.index()] != 0; } void mark_all_but(clause const & c, literal l); void unmark_all(clause const & c); void register_clauses(clause_vector & cs); void remove_clause_core(clause & c); void remove_clause(clause & c); void remove_clause(clause & c, literal l); void remove_bin_clause_half(literal l1, literal l2, bool learned); bool_var get_min_occ_var(clause const & c) const; bool subsumes1(clause const & c1, clause const & c2, literal & l); void collect_subsumed1_core(clause const & c, clause_vector & out, literal_vector & out_lits, literal target); void collect_subsumed1(clause const & c, clause_vector & out, literal_vector & out_lits); clause_vector m_bs_cs; literal_vector m_bs_ls; void back_subsumption1(clause & c); void back_subsumption1(literal l1, literal l2, bool learned); literal get_min_occ_var0(clause const & c) const; bool subsumes0(clause const & c1, clause const & c2); void collect_subsumed0_core(clause const & c1, clause_vector & out, literal target); void collect_subsumed0(clause const & c1, clause_vector & out); void back_subsumption0(clause & c1); bool cleanup_clause(clause & c); bool cleanup_clause(literal_vector & c); void propagate_unit(literal l); void elim_lit(clause & c, literal l); void elim_dup_bins(); bool subsume_with_binaries(); void mark_as_not_learned_core(watch_list & wlist, literal l2); void mark_as_not_learned(literal l1, literal l2); void subsume(); void cleanup_watches(); void cleanup_clauses(clause_vector & cs, bool learned, bool vars_eliminated); bool is_external(bool_var v) const; bool was_eliminated(bool_var v) const; lbool value(bool_var v) const; lbool value(literal l) const; watch_list & get_wlist(literal l); watch_list const & get_wlist(literal l) const; struct blocked_clause_elim; void elim_blocked_clauses(); unsigned get_num_non_learned_bin(literal l) const; unsigned get_to_elim_cost(bool_var v) const; void order_vars_for_elim(bool_var_vector & r); void collect_clauses(literal l, clause_wrapper_vector & r); clause_wrapper_vector m_pos_cls; clause_wrapper_vector m_neg_cls; literal_vector m_new_cls; bool resolve(clause_wrapper const & c1, clause_wrapper const & c2, literal l, literal_vector & r); void save_clauses(model_converter::entry & mc_entry, clause_wrapper_vector const & cs); void add_non_learned_binary_clause(literal l1, literal l2); void remove_bin_clauses(literal l); void remove_clauses(clause_use_list const & cs, literal l); bool try_eliminate(bool_var v); void elim_vars(); struct blocked_cls_report; struct subsumption_report; struct elim_var_report; public: simplifier(solver & s, params_ref const & p); ~simplifier(); void insert_todo(bool_var v) { m_elim_todo.insert(v); } void operator()(bool learned); void updt_params(params_ref const & p); static void collect_param_descrs(param_descrs & d); void free_memory(); void collect_statistics(statistics & st); void reset_statistics(); }; }; #endif