mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-04-10 19:27:06 +00:00
Code Activity

rename aig_simplifier to cut_simplifier

Browse source 
Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com>
This commit is contained in:
Nikolaj Bjorner 2020-02-18 18:29:59 -08:00
parent 8860de39bb
commit dd3e77107e
12 changed files with 599 additions and 598 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/sat/CMakeLists.txt
View file

@ -4,7 +4,6 @@ z3_add_component(sat
dimacs.cpp
sat_aig_cuts.cpp
sat_aig_finder.cpp
sat_aig_simplifier.cpp
sat_anf_simplifier.cpp
sat_asymm_branch.cpp
sat_big.cpp
@ -14,6 +13,7 @@ z3_add_component(sat
sat_clause_use_list.cpp
sat_cleaner.cpp
sat_config.cpp
sat_cut_simplifier.cpp
sat_cutset.cpp
sat_ddfw.cpp
sat_drat.cpp

7
src/sat/sat_config.cpp
View file

@ -103,9 +103,10 @@ namespace sat {
m_anf_simplify = p.anf();
m_anf_delay = p.anf_delay();
m_anf_exlin = p.anf_exlin();
m_aig_simplify = p.aig();
m_aig_delay = p.aig_delay();
m_aig_lut = p.aig_lut();
m_cut_simplify = p.cut();
m_cut_delay = p.cut_delay();
m_cut_lut = p.cut_lut();
m_cut_xor = p.cut_xor();
m_lookahead_simplify = p.lookahead_simplify();
m_lookahead_double = p.lookahead_double();
m_lookahead_simplify_bca = p.lookahead_simplify_bca();

7
src/sat/sat_config.h
View file

@ -120,9 +120,10 @@ namespace sat {
unsigned m_unit_walk_threads;
bool m_unit_walk;
bool m_binspr;
bool m_aig_simplify;
unsigned m_aig_delay;
bool m_aig_lut;
bool m_cut_simplify;
unsigned m_cut_delay;
bool m_cut_lut;
bool m_cut_xor;
bool m_anf_simplify;
unsigned m_anf_delay;
bool m_anf_exlin;

102
src/sat/sat_aig_simplifier.cpp → src/sat/sat_cut_simplifier.cpp
View file

@ -3,7 +3,7 @@
Module Name:
sat_aig_simplifier.cpp
sat_cut_simplifier.cpp
Abstract:
@ -16,19 +16,19 @@
--*/
#include "sat/sat_aig_simplifier.h"
#include "sat/sat_cut_simplifier.h"
#include "sat/sat_xor_finder.h"
#include "sat/sat_lut_finder.h"
#include "sat/sat_elim_eqs.h"
namespace sat {
struct aig_simplifier::report {
aig_simplifier& s;
struct cut_simplifier::report {
cut_simplifier& s;
stopwatch m_watch;
unsigned m_num_eqs, m_num_units, m_num_cuts, m_num_learned_implies;
report(aig_simplifier& s): s(s) {
report(cut_simplifier& s): s(s) {
m_watch.start();
m_num_eqs = s.m_stats.m_num_eqs;
m_num_units = s.m_stats.m_num_units;
@ -50,7 +50,7 @@ namespace sat {
}
};
struct aig_simplifier::validator {
struct cut_simplifier::validator {
solver& _s;
params_ref p;
literal_vector m_assumptions;
@ -80,7 +80,7 @@ namespace sat {
}
};
void aig_simplifier::ensure_validator() {
void cut_simplifier::ensure_validator() {
if (!m_validator) {
params_ref p;
p.set_bool("aig", false);
@ -91,7 +91,7 @@ namespace sat {
}
}
aig_simplifier::aig_simplifier(solver& _s):
cut_simplifier::cut_simplifier(solver& _s):
s(_s),
m_trail_size(0),
m_validator(nullptr) {
@ -113,11 +113,11 @@ namespace sat {
}
}
aig_simplifier::~aig_simplifier() {
cut_simplifier::~cut_simplifier() {
dealloc(m_validator);
}
void aig_simplifier::add_and(literal head, unsigned sz, literal const* lits) {
void cut_simplifier::add_and(literal head, unsigned sz, literal const* lits) {
m_aig_cuts.add_node(head, and_op, sz, lits);
m_stats.m_num_ands++;
}
@ -125,7 +125,7 @@ namespace sat {
// head == l1 or l2 or l3
// <=>
// ~head == ~l1 and ~l2 and ~l3
void aig_simplifier::add_or(literal head, unsigned sz, literal const* lits) {
void cut_simplifier::add_or(literal head, unsigned sz, literal const* lits) {
m_lits.reset();
m_lits.append(sz, lits);
for (unsigned i = 0; i < sz; ++i) m_lits[i].neg();
@ -133,31 +133,31 @@ namespace sat {
m_stats.m_num_ands++;
}
void aig_simplifier::add_xor(literal head, unsigned sz, literal const* lits) {
void cut_simplifier::add_xor(literal head, unsigned sz, literal const* lits) {
m_aig_cuts.add_node(head, xor_op, sz, lits);
m_stats.m_num_xors++;
}
void aig_simplifier::add_ite(literal head, literal c, literal t, literal e) {
void cut_simplifier::add_ite(literal head, literal c, literal t, literal e) {
literal lits[3] = { c, t, e };
m_aig_cuts.add_node(head, ite_op, 3, lits);
m_stats.m_num_ites++;
}
void aig_simplifier::add_iff(literal head, literal l1, literal l2) {
void cut_simplifier::add_iff(literal head, literal l1, literal l2) {
literal lits[2] = { l1, ~l2 };
m_aig_cuts.add_node(head, xor_op, 2, lits);
m_stats.m_num_xors++;
}
void aig_simplifier::set_root(bool_var v, literal r) {
void cut_simplifier::set_root(bool_var v, literal r) {
m_aig_cuts.set_root(v, r);
}
void aig_simplifier::operator()() {
void cut_simplifier::operator()() {
report _report(*this);
TRACE("aig_simplifier", s.display(tout););
TRACE("cut_simplifier", s.display(tout););
unsigned n = 0, i = 0;
++m_stats.m_num_calls;
do {
@ -173,7 +173,7 @@ namespace sat {
\brief extract AIG definitions from clauses
Ensure that they are sorted and variables have unique definitions.
*/
void aig_simplifier::clauses2aig() {
void cut_simplifier::clauses2aig() {
// update units
for (; m_config.m_enable_units && m_trail_size < s.init_trail_size(); ++m_trail_size) {
@ -215,7 +215,7 @@ namespace sat {
// <=>
// ~head = t1 + t2 + ..
literal head = ~xors[index];
TRACE("aig_simplifier", tout << xors << "\n";);
TRACE("cut_simplifier", tout << xors << "\n";);
unsigned sz = xors.size() - 1;
m_lits.reset();
for (unsigned i = xors.size(); i-- > 0; ) {
@ -226,14 +226,12 @@ namespace sat {
m_lits.reset();
m_stats.m_xxors++;
};
#if 0
//
xor_finder xf(s);
xf.set(on_xor);
xf(clauses);
#endif
if (s.m_config.m_aig_lut) {
if (s.m_config.m_cut_xor) {
xor_finder xf(s);
xf.set(on_xor);
xf(clauses);
}
if (s.m_config.m_cut_lut) {
std::function<void(uint64_t, bool_var_vector const&, bool_var)> on_lut =
[&,this](uint64_t lut, bool_var_vector const& vars, bool_var v) {
m_stats.m_xluts++;
@ -253,7 +251,7 @@ namespace sat {
#endif
}
void aig_simplifier::aig2clauses() {
void cut_simplifier::aig2clauses() {
vector<cut_set> const& cuts = m_aig_cuts();
m_stats.m_num_cuts = m_aig_cuts.num_cuts();
add_dont_cares(cuts);
@ -262,7 +260,7 @@ namespace sat {
simulate_eqs();
}
void aig_simplifier::cuts2equiv(vector<cut_set> const& cuts) {
void cut_simplifier::cuts2equiv(vector<cut_set> const& cuts) {
map<cut const*, unsigned, cut::hash_proc, cut::eq_proc> cut2id;
bool new_eq = false;
union_find_default_ctx ctx;
@ -307,7 +305,7 @@ namespace sat {
}
}
void aig_simplifier::assign_unit(cut const& c, literal lit) {
void cut_simplifier::assign_unit(cut const& c, literal lit) {
if (s.value(lit) != l_undef)
return;
IF_VERBOSE(10, verbose_stream() << "new unit " << lit << "\n");
@ -317,10 +315,10 @@ namespace sat {
++m_stats.m_num_units;
}
void aig_simplifier::assign_equiv(cut const& c, literal u, literal v) {
void cut_simplifier::assign_equiv(cut const& c, literal u, literal v) {
if (u.var() == v.var()) return;
IF_VERBOSE(10, verbose_stream() << u << " " << v << " " << c << "\n";);
TRACE("aig_simplifier", tout << u << " == " << v << "\n";);
TRACE("cut_simplifier", tout << u << " == " << v << "\n";);
certify_equivalence(u, v, c);
validate_eq(u, v);
}
@ -328,7 +326,7 @@ namespace sat {
/**
* Convert a union-find over literals into input for eim_eqs.
*/
void aig_simplifier::uf2equiv(union_find<> const& uf) {
void cut_simplifier::uf2equiv(union_find<> const& uf) {
union_find_default_ctx ctx;
union_find<> uf2(ctx);
bool new_eq = false;
@ -366,7 +364,7 @@ namespace sat {
* that sets a subset of bits for LUT' of v establishes
* that u implies v.
*/
void aig_simplifier::cuts2implies(vector<cut_set> const& cuts) {
void cut_simplifier::cuts2implies(vector<cut_set> const& cuts) {
if (!m_config.m_learn_implies) return;
vector<vector<std::pair<unsigned, cut const*>>> var_tables;
map<cut const*, unsigned, cut::dom_hash_proc, cut::dom_eq_proc> cut2tables;
@ -421,7 +419,7 @@ namespace sat {
}
}
void aig_simplifier::learn_implies(big& big, cut const& c, literal u, literal v) {
void cut_simplifier::learn_implies(big& big, cut const& c, literal u, literal v) {
if (u == ~v) {
assign_unit(c, v);
return;
@ -444,7 +442,7 @@ namespace sat {
++m_stats.m_num_learned_implies;
}
void aig_simplifier::simulate_eqs() {
void cut_simplifier::simulate_eqs() {
if (!m_config.m_simulate_eqs) return;
auto var2val = m_aig_cuts.simulate(4);
@ -476,7 +474,7 @@ namespace sat {
IF_VERBOSE(2, verbose_stream() << "(sat.aig-simplifier num simulated eqs " << num_eqs << ")\n");
}
void aig_simplifier::track_binary(bin_rel const& p) {
void cut_simplifier::track_binary(bin_rel const& p) {
if (!s.m_config.m_drat)
return;
literal u, v;
@ -484,7 +482,7 @@ namespace sat {
track_binary(u, v);
}
void aig_simplifier::untrack_binary(bin_rel const& p) {
void cut_simplifier::untrack_binary(bin_rel const& p) {
if (!s.m_config.m_drat)
return;
literal u, v;
@ -492,19 +490,19 @@ namespace sat {
untrack_binary(u, v);
}
void aig_simplifier::track_binary(literal u, literal v) {
void cut_simplifier::track_binary(literal u, literal v) {
if (s.m_config.m_drat) {
s.m_drat.add(u, v, true);
}
}
void aig_simplifier::untrack_binary(literal u, literal v) {
void cut_simplifier::untrack_binary(literal u, literal v) {
if (s.m_config.m_drat) {
s.m_drat.del(u, v);
}
}
void aig_simplifier::certify_unit(literal u, cut const& c) {
void cut_simplifier::certify_unit(literal u, cut const& c) {
certify_implies(~u, u, c);
}
@ -515,7 +513,7 @@ namespace sat {
* each resolvent is DRAT derivable because there are two previous lemmas that
* contain complementary literals.
*/
void aig_simplifier::certify_equivalence(literal u, literal v, cut const& c) {
void cut_simplifier::certify_equivalence(literal u, literal v, cut const& c) {
certify_implies(u, v, c);
certify_implies(v, u, c);
}
@ -528,7 +526,7 @@ namespace sat {
* Thus, for every clause C or u', where u' is u or ~u,
* it follows that C or ~u or v
*/
void aig_simplifier::certify_implies(literal u, literal v, cut const& c) {
void cut_simplifier::certify_implies(literal u, literal v, cut const& c) {
if (!s.m_config.m_drat) return;
vector<literal_vector> clauses;
@ -568,7 +566,7 @@ namespace sat {
}
}
void aig_simplifier::add_dont_cares(vector<cut_set> const& cuts) {
void cut_simplifier::add_dont_cares(vector<cut_set> const& cuts) {
if (!m_config.m_enable_dont_cares)
return;
cuts2bins(cuts);
@ -579,7 +577,7 @@ namespace sat {
/**
* Collect binary relations between variables that occur in cut sets.
*/
void aig_simplifier::cuts2bins(vector<cut_set> const& cuts) {
void cut_simplifier::cuts2bins(vector<cut_set> const& cuts) {
svector<bin_rel> dcs;
for (auto const& p : m_bins) {
if (p.op != none)
@ -609,7 +607,7 @@ namespace sat {
/**
* Compute masks for binary relations.
*/
void aig_simplifier::bins2dont_cares() {
void cut_simplifier::bins2dont_cares() {
big b(s.rand());
b.init(s, true);
for (auto& p : m_bins) {
@ -643,7 +641,7 @@ namespace sat {
* to a cut, then ensure that the variable is "touched" so that it participates
* in the next propagation.
*/
void aig_simplifier::dont_cares2cuts(vector<cut_set> const& cuts) {
void cut_simplifier::dont_cares2cuts(vector<cut_set> const& cuts) {
for (auto& cs : cuts) {
for (auto const& c : cs) {
if (add_dont_care(c)) {
@ -663,7 +661,7 @@ namespace sat {
* Don't care positions are spaced apart by 2^{j+1},
* where j is the second variable position.
*/
uint64_t aig_simplifier::op2dont_care(unsigned i, unsigned j, bin_rel const& p) {
uint64_t cut_simplifier::op2dont_care(unsigned i, unsigned j, bin_rel const& p) {
SASSERT(i < j && j < 6);
if (p.op == none) return 0ull;
// first position of mask is offset into output bits contributed by i and j
@ -681,7 +679,7 @@ namespace sat {
* The don't care bits are added to the LUT, so that the
* output is always 1 on don't care combinations.
*/
bool aig_simplifier::add_dont_care(cut const & c) {
bool cut_simplifier::add_dont_care(cut const & c) {
uint64_t dc = 0;
for (unsigned i = 0; i < c.size(); ++i) {
for (unsigned j = i + 1; j < c.size(); ++j) {
@ -694,7 +692,7 @@ namespace sat {
return (dc != c.dont_care()) && (c.add_dont_care(dc), true);
}
void aig_simplifier::collect_statistics(statistics& st) const {
void cut_simplifier::collect_statistics(statistics& st) const {
st.update("sat-aig.eqs", m_stats.m_num_eqs);
st.update("sat-aig.cuts", m_stats.m_num_cuts);
st.update("sat-aig.ands", m_stats.m_num_ands);
@ -707,13 +705,13 @@ namespace sat {
st.update("sat-aig.dc-reduce", m_stats.m_num_dont_care_reductions);
}
void aig_simplifier::validate_unit(literal lit) {
void cut_simplifier::validate_unit(literal lit) {
if (!m_config.m_validate_lemmas) return;
ensure_validator();
m_validator->validate(1, &lit);
}
void aig_simplifier::validate_eq(literal a, literal b) {
void cut_simplifier::validate_eq(literal a, literal b) {
if (!m_config.m_validate_lemmas) return;
ensure_validator();
literal lits1[2] = { a, ~b };

8
src/sat/sat_aig_simplifier.h → src/sat/sat_cut_simplifier.h
View file

@ -3,7 +3,7 @@
Module Name:
sat_aig_simplifier.h
sat_cut_simplifier.h
Abstract:
@ -24,7 +24,7 @@
namespace sat {
class aig_simplifier {
class cut_simplifier {
public:
struct stats {
unsigned m_num_eqs, m_num_units, m_num_cuts, m_num_xors, m_num_ands, m_num_ites;
@ -150,8 +150,8 @@ namespace sat {
uint64_t op2dont_care(unsigned i, unsigned j, bin_rel const& p);
public:
aig_simplifier(solver& s);
~aig_simplifier();
cut_simplifier(solver& s);
~cut_simplifier();
void operator()();
void collect_statistics(statistics& st) const;

1030
src/sat/sat_cutset_compute_shift.h
View file

File diff suppressed because it is too large Load diff

2
src/sat/sat_elim_eqs.cpp
View file

@ -230,7 +230,7 @@ namespace sat {
literal l(v, false);
literal r = roots[v];
SASSERT(v != r.var());
if (m_solver.m_aig_simplifier) m_solver.m_aig_simplifier->set_root(v, r);
if (m_solver.m_cut_simplifier) m_solver.m_cut_simplifier->set_root(v, r);
bool set_root = m_solver.set_root(l, r);
bool root_ok = !m_solver.is_external(v) || set_root;
if (m_solver.is_assumption(v) || (m_solver.is_external(v) && (m_solver.is_incremental() || !root_ok))) {

7
src/sat/sat_params.pyg
View file

@ -73,9 +73,10 @@ def_module_params('sat',
('anf', BOOL, False, 'enable ANF based simplification in-processing'),
('anf.delay', UINT, 2, 'delay ANF simplification by in-processing round'),
('anf.exlin', BOOL, False, 'enable extended linear simplification'),
('aig', BOOL, False, 'enable AIG based simplification in-processing'),
('aig.delay', UINT, 2, 'delay AIG simplification by in-processing round'),
('aig.lut', BOOL, False, 'extract luts from clauses'),
('cut', BOOL, False, 'enable AIG based simplification in-processing'),
('cut.delay', UINT, 2, 'delay cut simplification by in-processing round'),
('cut.lut', BOOL, False, 'extract luts from clauses for cut simplification'),
('cut.xor', BOOL, False, 'extract xors from clauses for cut simplification'),
('lookahead.cube.cutoff', SYMBOL, 'depth', 'cutoff type used to create lookahead cubes: depth, freevars, psat, adaptive_freevars, adaptive_psat'),
# - depth: the maximal cutoff is fixed to the value of lookahead.cube.depth.
# So if the value is 10, at most 1024 cubes will be generated of length 10.

14
src/sat/sat_solver.cpp
View file

@ -31,7 +31,7 @@ Revision History:
#include "sat/sat_ddfw.h"
#include "sat/sat_prob.h"
#include "sat/sat_anf_simplifier.h"
#include "sat/sat_aig_simplifier.h"
#include "sat/sat_cut_simplifier.h"
#if defined(_MSC_VER) && !defined(_M_ARM) && !defined(_M_ARM64)
# include <xmmintrin.h>
#endif
@ -1931,8 +1931,8 @@ namespace sat {
// TBD: throttle anf_delay based on yield
}
if (m_aig_simplifier && m_simplifications > m_config.m_aig_delay && !inconsistent()) {
(*m_aig_simplifier)();
if (m_cut_simplifier && m_simplifications > m_config.m_cut_delay && !inconsistent()) {
(*m_cut_simplifier)();
}
}
@ -3762,7 +3762,7 @@ namespace sat {
bool_var new_v = mk_var(true, false);
lit = literal(new_v, false);
m_user_scope_literals.push_back(lit);
m_aig_simplifier = nullptr; // for simplicity, wipe it out
m_cut_simplifier = nullptr; // for simplicity, wipe it out
TRACE("sat", tout << "user_push: " << lit << "\n";);
}
@ -3915,8 +3915,8 @@ namespace sat {
m_slow_glue_backup.set_alpha(m_config.m_slow_glue_avg);
m_trail_avg.set_alpha(m_config.m_slow_glue_avg);
if (m_config.m_aig_simplify && !m_aig_simplifier && m_user_scope_literals.empty()) {
m_aig_simplifier = alloc(aig_simplifier, *this);
if (m_config.m_cut_simplify && !m_cut_simplifier && m_user_scope_literals.empty()) {
m_cut_simplifier = alloc(cut_simplifier, *this);
}
}
@ -3937,7 +3937,7 @@ namespace sat {
m_probing.collect_statistics(st);
if (m_ext) m_ext->collect_statistics(st);
if (m_local_search) m_local_search->collect_statistics(st);
if (m_aig_simplifier) m_aig_simplifier->collect_statistics(st);
if (m_cut_simplifier) m_cut_simplifier->collect_statistics(st);
st.copy(m_aux_stats);
}

8
src/sat/sat_solver.h
View file

@ -31,7 +31,7 @@ Revision History:
#include "sat/sat_simplifier.h"
#include "sat/sat_scc.h"
#include "sat/sat_asymm_branch.h"
#include "sat/sat_aig_simplifier.h"
#include "sat/sat_cut_simplifier.h"
#include "sat/sat_probing.h"
#include "sat/sat_mus.h"
#include "sat/sat_binspr.h"
@ -89,7 +89,7 @@ namespace sat {
config m_config;
stats m_stats;
scoped_ptr<extension> m_ext;
scoped_ptr<aig_simplifier> m_aig_simplifier;
scoped_ptr<cut_simplifier> m_cut_simplifier;
parallel* m_par;
drat m_drat; // DRAT for generating proofs
clause_allocator m_cls_allocator[2];
@ -207,7 +207,7 @@ namespace sat {
friend class scc;
friend class ba_solver;
friend class anf_simplifier;
friend class aig_simplifier;
friend class cut_simplifier;
friend class parallel;
friend class lookahead;
friend class local_search;
@ -401,7 +401,7 @@ namespace sat {
bool is_incremental() const { return m_config.m_incremental; }
extension* get_extension() const override { return m_ext.get(); }
void set_extension(extension* e) override;
aig_simplifier* get_aig_simplifier() override { return m_aig_simplifier.get(); }
cut_simplifier* get_cut_simplifier() override { return m_cut_simplifier.get(); }
bool set_root(literal l, literal r);
void flush_roots();
typedef std::pair<literal, literal> bin_clause;

4
src/sat/sat_solver_core.h
View file

@ -24,7 +24,7 @@ Revision History:
namespace sat {
class aig_simplifier;
class cut_simplifier;
class extension;
class solver_core {
@ -92,7 +92,7 @@ namespace sat {
virtual extension* get_extension() const { return nullptr; }
virtual void set_extension(extension* e) { if (e) throw default_exception("optional API not supported"); }
virtual aig_simplifier* get_aig_simplifier() { return nullptr; }
virtual cut_simplifier* get_cut_simplifier() { return nullptr; }
// The following methods are used when converting the state from the SAT solver back

6
src/sat/tactic/goal2sat.cpp
View file

@ -35,7 +35,7 @@ Notes:
#include "ast/for_each_expr.h"
#include "sat/tactic/goal2sat.h"
#include "sat/ba_solver.h"
#include "sat/sat_aig_simplifier.h"
#include "sat/sat_cut_simplifier.h"
#include "model/model_evaluator.h"
#include "model/model_v2_pp.h"
#include "tactic/tactic.h"
@ -54,7 +54,7 @@ struct goal2sat::imp {
ast_manager & m;
pb_util pb;
sat::ba_solver* m_ext;
sat::aig_simplifier* m_aig;
sat::cut_simplifier* m_aig;
svector<frame> m_frame_stack;
svector<sat::literal> m_result_stack;
obj_map<app, sat::literal> m_cache;
@ -85,7 +85,7 @@ struct goal2sat::imp {
m_is_lemma(false) {
updt_params(p);
m_true = sat::null_literal;
m_aig = s.get_aig_simplifier();
m_aig = s.get_cut_simplifier();
}
void updt_params(params_ref const & p) {