mirror of
https://github.com/Z3Prover/z3
synced 2025-04-23 09:05:31 +00:00
Merge remote-tracking branch 'origin/master' into poly
This commit is contained in:
Jakob Rath
commit
183e911a79
260 changed files with 4131 additions and 3248 deletions
|
|
@ -984,7 +984,8 @@ bool arith_util::is_extended_numeral(expr* term, rational& r) const {
|
|||
return true;
|
||||
}
|
||||
return false;
|
||||
} while (false);
|
||||
}
|
||||
while (true);
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -49,7 +49,7 @@ sort * array_decl_plugin::mk_sort(decl_kind k, unsigned num_parameters, paramete
|
|||
m_manager->raise_exception("invalid array sort definition, invalid number of parameters");
|
||||
return nullptr;
|
||||
}
|
||||
parameter params[2] = { parameters[0], parameter(m_manager->mk_bool_sort()) };
|
||||
parameter params[2] = { parameter(parameters[0]), parameter(m_manager->mk_bool_sort()) };
|
||||
return mk_sort(ARRAY_SORT, 2, params);
|
||||
}
|
||||
SASSERT(k == ARRAY_SORT);
|
||||
|
|
|
|||
|
|
@ -48,21 +48,13 @@ parameter::~parameter() {
|
|||
}
|
||||
}
|
||||
|
||||
parameter& parameter::operator=(parameter const& other) {
|
||||
if (this == &other) {
|
||||
return *this;
|
||||
}
|
||||
|
||||
this->~parameter();
|
||||
m_val = other.m_val;
|
||||
|
||||
parameter::parameter(parameter const& other) : m_val(other.m_val) {
|
||||
if (auto p = std::get_if<rational*>(&m_val)) {
|
||||
m_val = alloc(rational, **p);
|
||||
}
|
||||
if (auto p = std::get_if<zstring*>(&m_val)) {
|
||||
m_val = alloc(zstring, **p);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
void parameter::init_eh(ast_manager & m) {
|
||||
|
|
@ -319,26 +311,6 @@ func_decl::func_decl(symbol const & name, unsigned arity, sort * const * domain,
|
|||
//
|
||||
// -----------------------------------
|
||||
|
||||
static app_flags mk_const_flags() {
|
||||
app_flags r;
|
||||
r.m_depth = 1;
|
||||
r.m_ground = true;
|
||||
r.m_has_quantifiers = false;
|
||||
r.m_has_labels = false;
|
||||
return r;
|
||||
}
|
||||
|
||||
static app_flags mk_default_app_flags() {
|
||||
app_flags r;
|
||||
r.m_depth = 1;
|
||||
r.m_ground = true;
|
||||
r.m_has_quantifiers = false;
|
||||
r.m_has_labels = false;
|
||||
return r;
|
||||
}
|
||||
|
||||
app_flags app::g_constant_flags = mk_const_flags();
|
||||
|
||||
app::app(func_decl * decl, unsigned num_args, expr * const * args):
|
||||
expr(AST_APP),
|
||||
m_decl(decl),
|
||||
|
|
@ -1762,8 +1734,7 @@ ast * ast_manager::register_node_core(ast * n) {
|
|||
inc_ref(t->get_decl());
|
||||
unsigned num_args = t->get_num_args();
|
||||
if (num_args > 0) {
|
||||
app_flags * f = t->flags();
|
||||
*f = mk_default_app_flags();
|
||||
app_flags * f = &t->m_flags;
|
||||
SASSERT(t->is_ground());
|
||||
SASSERT(!t->has_quantifiers());
|
||||
SASSERT(!t->has_labels());
|
||||
|
|
@ -1776,13 +1747,13 @@ ast * ast_manager::register_node_core(ast * n) {
|
|||
unsigned arg_depth = 0;
|
||||
switch (arg->get_kind()) {
|
||||
case AST_APP: {
|
||||
app_flags * arg_flags = to_app(arg)->flags();
|
||||
arg_depth = arg_flags->m_depth;
|
||||
if (arg_flags->m_has_quantifiers)
|
||||
app *app = to_app(arg);
|
||||
arg_depth = app->get_depth();
|
||||
if (app->has_quantifiers())
|
||||
f->m_has_quantifiers = true;
|
||||
if (arg_flags->m_has_labels)
|
||||
if (app->has_labels())
|
||||
f->m_has_labels = true;
|
||||
if (!arg_flags->m_ground)
|
||||
if (!app->is_ground())
|
||||
f->m_ground = false;
|
||||
break;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -142,7 +142,7 @@ public:
|
|||
explicit parameter(const char *s): m_val(symbol(s)) {}
|
||||
explicit parameter(const std::string &s): m_val(symbol(s)) {}
|
||||
explicit parameter(unsigned ext_id, bool): m_val(ext_id) {}
|
||||
parameter(parameter const& other) { *this = other; }
|
||||
explicit parameter(parameter const& other);
|
||||
|
||||
parameter(parameter && other) noexcept : m_val(std::move(other.m_val)) {
|
||||
other.m_val = 0;
|
||||
|
|
@ -150,7 +150,10 @@ public:
|
|||
|
||||
~parameter();
|
||||
|
||||
parameter& operator=(parameter const& other);
|
||||
parameter& operator=(parameter && other) {
|
||||
std::swap(other.m_val, m_val);
|
||||
return *this;
|
||||
}
|
||||
|
||||
kind_t get_kind() const { return static_cast<kind_t>(m_val.index()); }
|
||||
bool is_int() const { return get_kind() == PARAM_INT; }
|
||||
|
|
@ -704,6 +707,7 @@ struct app_flags {
|
|||
unsigned m_ground:1; // application does not have free variables or nested quantifiers.
|
||||
unsigned m_has_quantifiers:1; // application has nested quantifiers.
|
||||
unsigned m_has_labels:1; // application has nested labels.
|
||||
app_flags() : m_depth(1), m_ground(1), m_has_quantifiers(0), m_has_labels(0) {}
|
||||
};
|
||||
|
||||
class app : public expr {
|
||||
|
|
@ -711,19 +715,15 @@ class app : public expr {
|
|||
|
||||
func_decl * m_decl;
|
||||
unsigned m_num_args;
|
||||
app_flags m_flags;
|
||||
expr * m_args[0];
|
||||
|
||||
static app_flags g_constant_flags;
|
||||
|
||||
// remark: store term depth in the end of the app. the depth is only stored if the num_args > 0
|
||||
static unsigned get_obj_size(unsigned num_args) {
|
||||
return num_args == 0 ? sizeof(app) : sizeof(app) + num_args * sizeof(expr *) + sizeof(app_flags);
|
||||
return sizeof(app) + num_args * sizeof(expr *);
|
||||
}
|
||||
|
||||
friend class tmp_app;
|
||||
|
||||
app_flags * flags() const { return m_num_args == 0 ? &g_constant_flags : reinterpret_cast<app_flags*>(const_cast<expr**>(m_args + m_num_args)); }
|
||||
|
||||
app(func_decl * decl, unsigned num_args, expr * const * args);
|
||||
public:
|
||||
func_decl * get_decl() const { return m_decl; }
|
||||
|
|
@ -744,10 +744,10 @@ public:
|
|||
expr * const * end() const { return m_args + m_num_args; }
|
||||
sort * _get_sort() const { return get_decl()->get_range(); }
|
||||
|
||||
unsigned get_depth() const { return flags()->m_depth; }
|
||||
bool is_ground() const { return flags()->m_ground; }
|
||||
bool has_quantifiers() const { return flags()->m_has_quantifiers; }
|
||||
bool has_labels() const { return flags()->m_has_labels; }
|
||||
unsigned get_depth() const { return m_flags.m_depth; }
|
||||
bool is_ground() const { return m_flags.m_ground; }
|
||||
bool has_quantifiers() const { return m_flags.m_has_quantifiers; }
|
||||
bool has_labels() const { return m_flags.m_has_labels; }
|
||||
};
|
||||
|
||||
// -----------------------------------
|
||||
|
|
@ -1102,7 +1102,7 @@ public:
|
|||
|
||||
// Event handlers for deleting/translating PARAM_EXTERNAL
|
||||
virtual void del(parameter const & p) {}
|
||||
virtual parameter translate(parameter const & p, decl_plugin & target) { UNREACHABLE(); return p; }
|
||||
virtual parameter translate(parameter const & p, decl_plugin & target) { UNREACHABLE(); return {}; }
|
||||
|
||||
virtual bool is_considered_uninterpreted(func_decl * f) { return false; }
|
||||
};
|
||||
|
|
|
|||
|
|
@ -68,8 +68,8 @@ bool lt(ast * n1, ast * n2) {
|
|||
num = to_sort(n1)->get_num_parameters();
|
||||
SASSERT(num > 0);
|
||||
for (unsigned i = 0; i < num; i++) {
|
||||
parameter p1 = to_sort(n1)->get_parameter(i);
|
||||
parameter p2 = to_sort(n2)->get_parameter(i);
|
||||
const parameter &p1 = to_sort(n1)->get_parameter(i);
|
||||
const parameter &p2 = to_sort(n2)->get_parameter(i);
|
||||
check_parameter(p1, p2);
|
||||
}
|
||||
UNREACHABLE();
|
||||
|
|
@ -80,8 +80,8 @@ bool lt(ast * n1, ast * n2) {
|
|||
check_value(to_func_decl(n1)->get_num_parameters(), to_func_decl(n2)->get_num_parameters());
|
||||
num = to_func_decl(n1)->get_num_parameters();
|
||||
for (unsigned i = 0; i < num; i++) {
|
||||
parameter p1 = to_func_decl(n1)->get_parameter(i);
|
||||
parameter p2 = to_func_decl(n2)->get_parameter(i);
|
||||
const parameter &p1 = to_func_decl(n1)->get_parameter(i);
|
||||
const parameter &p2 = to_func_decl(n2)->get_parameter(i);
|
||||
check_parameter(p1, p2);
|
||||
}
|
||||
num = to_func_decl(n1)->get_arity();
|
||||
|
|
|
|||
|
|
@ -58,13 +58,13 @@ inline std::ostream& operator<<(std::ostream & out, mk_pp_vec const & pp) {
|
|||
inline std::string operator+(char const* s, mk_pp const& pp) {
|
||||
std::ostringstream strm;
|
||||
strm << s << pp;
|
||||
return strm.str();
|
||||
return std::move(strm).str();
|
||||
}
|
||||
|
||||
inline std::string operator+(std::string const& s, mk_pp const& pp) {
|
||||
std::ostringstream strm;
|
||||
strm << s << pp;
|
||||
return strm.str();
|
||||
return std::move(strm).str();
|
||||
}
|
||||
|
||||
inline std::string& operator+=(std::string& s, mk_pp const& pp) {
|
||||
|
|
|
|||
|
|
@ -454,9 +454,8 @@ func_decl * bv_decl_plugin::mk_num_decl(unsigned num_parameters, parameter const
|
|||
// This cannot be enforced now, since some Z3 modules try to generate these invalid numerals.
|
||||
// After SMT-COMP, I should find all offending modules.
|
||||
// For now, I will just simplify the numeral here.
|
||||
rational v = parameters[0].get_rational();
|
||||
parameter p0(mod2k(v, bv_size));
|
||||
parameter ps[2] = { std::move(p0), parameters[1] };
|
||||
const rational &v = parameters[0].get_rational();
|
||||
parameter ps[2] = { parameter(mod2k(v, bv_size)), parameter(parameters[1]) };
|
||||
sort * bv = get_bv_sort(bv_size);
|
||||
return m_manager->mk_const_decl(m_bv_sym, bv, func_decl_info(m_family_id, OP_BV_NUM, num_parameters, ps));
|
||||
}
|
||||
|
|
@ -913,13 +912,9 @@ app * bv_util::mk_numeral(rational const & val, unsigned bv_size) const {
|
|||
|
||||
if (m_plugin->log_constant_meaning_prelude(r)) {
|
||||
if (bv_size % 4 == 0) {
|
||||
m_manager.trace_stream() << "#x";
|
||||
val.display_hex(m_manager.trace_stream(), bv_size);
|
||||
m_manager.trace_stream() << "\n";
|
||||
m_manager.trace_stream() << "#x" << val.as_hex(bv_size) << "\n";
|
||||
} else {
|
||||
m_manager.trace_stream() << "#b";
|
||||
val.display_bin(m_manager.trace_stream(), bv_size);
|
||||
m_manager.trace_stream() << "\n";
|
||||
m_manager.trace_stream() << "#b" << val.as_bin(bv_size) << "\n";
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -400,6 +400,7 @@ class bv_expr_inverter : public iexpr_inverter {
|
|||
}
|
||||
|
||||
bool process_concat(func_decl* f, unsigned num, expr* const* args, expr_ref& r) {
|
||||
// return false;
|
||||
if (num == 0)
|
||||
return false;
|
||||
if (!uncnstr(num, args))
|
||||
|
|
|
|||
|
|
@ -43,6 +43,7 @@ void generic_model_converter::operator()(model_ref & md) {
|
|||
expr_ref val(m);
|
||||
unsigned arity;
|
||||
bool reset_ev = false;
|
||||
obj_map<sort, ptr_vector<expr>> uninterpreted;
|
||||
for (unsigned i = m_entries.size(); i-- > 0; ) {
|
||||
entry const& e = m_entries[i];
|
||||
switch (e.m_instruction) {
|
||||
|
|
@ -63,6 +64,13 @@ void generic_model_converter::operator()(model_ref & md) {
|
|||
reset_ev = old_val != nullptr;
|
||||
md->register_decl(e.m_f, val);
|
||||
}
|
||||
// corner case when uninterpreted constants are eliminated
|
||||
sort* s = e.m_f->get_range();
|
||||
if (m.is_uninterp(s) && !md->has_uninterpreted_sort(s)) {
|
||||
uninterpreted.insert_if_not_there(s, {});
|
||||
if (!uninterpreted[s].contains(val))
|
||||
uninterpreted[s].push_back(val);
|
||||
}
|
||||
}
|
||||
else {
|
||||
func_interp * old_val = md->get_func_interp(e.m_f);
|
||||
|
|
@ -84,6 +92,9 @@ void generic_model_converter::operator()(model_ref & md) {
|
|||
break;
|
||||
}
|
||||
}
|
||||
for (auto const& [s, u] : uninterpreted) {
|
||||
md->register_usort(s, u.size(), u.data());
|
||||
}
|
||||
TRACE("model_converter", tout << "after generic_model_converter\n"; model_v2_pp(tout, *md););
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -68,6 +68,8 @@ public:
|
|||
void get_units(obj_map<expr, bool>& units) override;
|
||||
|
||||
vector<entry> const& entries() const { return m_entries; }
|
||||
|
||||
void reset() { m_entries.reset(); }
|
||||
};
|
||||
|
||||
typedef ref<generic_model_converter> generic_model_converter_ref;
|
||||
|
|
|
|||
|
|
@ -59,9 +59,9 @@ TODOs:
|
|||
- The shared terms hash table is not incremental.
|
||||
It could be made incremental by updating it on every merge similar to how the egraph handles it.
|
||||
- V2 using multiplicities instead of repeated values in monomials.
|
||||
- Squash trail updates when equations or monomials are modified within the same epoque.
|
||||
- by an epoque counter that can be updated by the egraph class whenever there is a push/pop.
|
||||
- store the epoque as a tick on equations and possibly when updating monomials on equations.
|
||||
- Squash trail updates when equations or monomials are modified within the same epoch.
|
||||
- by an epoch counter that can be updated by the egraph class whenever there is a push/pop.
|
||||
- store the epoch as a tick on equations and possibly when updating monomials on equations.
|
||||
|
||||
--*/
|
||||
|
||||
|
|
@ -80,7 +80,7 @@ namespace euf {
|
|||
}
|
||||
|
||||
ac_plugin::ac_plugin(egraph& g, func_decl* f) :
|
||||
plugin(g), m_fid(f->get_family_id()), m_decl(f),
|
||||
plugin(g), m_fid(f->get_family_id()), m_decl(f),
|
||||
m_dep_manager(get_region()),
|
||||
m_hash(*this), m_eq(*this), m_monomial_table(m_hash, m_eq)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -40,7 +40,7 @@ namespace euf {
|
|||
struct node {
|
||||
enode* n; // associated enode
|
||||
node* root; // path compressed root
|
||||
node* next; // next in equaivalence class
|
||||
node* next; // next in equivalence class
|
||||
justification j; // justification for equality
|
||||
node* target = nullptr; // justified next
|
||||
unsigned_vector shared; // shared occurrences
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@ Module Name:
|
|||
|
||||
Abstract:
|
||||
|
||||
plugin structure for arithetic
|
||||
plugin structure for arithmetic
|
||||
|
||||
Author:
|
||||
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@ Module Name:
|
|||
|
||||
Abstract:
|
||||
|
||||
plugin structure for arithetic
|
||||
plugin structure for arithmetic
|
||||
Author:
|
||||
|
||||
Nikolaj Bjorner (nbjorner) 2023-11-11
|
||||
|
|
|
|||
|
|
@ -319,7 +319,7 @@ func_interp * bv2fpa_converter::convert_func_interp(model_core * mc, func_decl *
|
|||
|
||||
if (m_fpa_util.is_to_sbv(f) || m_fpa_util.is_to_ubv(f)) {
|
||||
auto k = m_fpa_util.is_to_sbv(f) ? OP_FPA_TO_SBV_I : OP_FPA_TO_UBV_I;
|
||||
parameter param = f->get_parameter(0);
|
||||
const parameter ¶m = f->get_parameter(0);
|
||||
func_decl_ref to_bv_i(m.mk_func_decl(fid, k, 1, ¶m, dom.size(), dom.data()), m);
|
||||
expr_ref else_value(m.mk_app(to_bv_i, dom.size(), dom.data()), m);
|
||||
result->set_else(else_value);
|
||||
|
|
|
|||
|
|
@ -208,8 +208,7 @@ sort * fpa_decl_plugin::mk_float_sort(unsigned ebits, unsigned sbits) {
|
|||
if (ebits > 63)
|
||||
m_manager->raise_exception("maximum number of exponent bits is 63");
|
||||
|
||||
parameter p1(ebits), p2(sbits);
|
||||
parameter ps[2] = { p1, p2 };
|
||||
parameter ps[2] = { parameter(ebits), parameter(sbits) };
|
||||
sort_size sz;
|
||||
sz = sort_size::mk_very_big(); // TODO: refine
|
||||
return m_manager->mk_sort(symbol("FloatingPoint"), sort_info(m_family_id, FLOATING_POINT_SORT, sz, 2, ps));
|
||||
|
|
|
|||
|
|
@ -40,7 +40,7 @@ namespace polymorphism {
|
|||
unsigned n = s->get_num_parameters();
|
||||
vector<parameter> ps;
|
||||
for (unsigned i = 0; i < n; ++i) {
|
||||
auto p = s->get_parameter(i);
|
||||
auto &p = s->get_parameter(i);
|
||||
if (p.is_ast() && is_sort(p.get_ast())) {
|
||||
sort_ref s = (*this)(to_sort(p.get_ast()));
|
||||
ps.push_back(parameter(s.get()));
|
||||
|
|
@ -167,8 +167,8 @@ namespace polymorphism {
|
|||
if (s1->get_num_parameters() != s2->get_num_parameters())
|
||||
return false;
|
||||
for (unsigned i = s1->get_num_parameters(); i-- > 0;) {
|
||||
auto p1 = s1->get_parameter(i);
|
||||
auto p2 = s2->get_parameter(i);
|
||||
auto &p1 = s1->get_parameter(i);
|
||||
auto &p2 = s2->get_parameter(i);
|
||||
if (p1.is_ast() && is_sort(p1.get_ast())) {
|
||||
if (!p2.is_ast())
|
||||
return false;
|
||||
|
|
@ -204,8 +204,8 @@ namespace polymorphism {
|
|||
if (s1->get_num_parameters() != s2->get_num_parameters())
|
||||
return false;
|
||||
for (unsigned i = s1->get_num_parameters(); i-- > 0;) {
|
||||
auto p1 = s1->get_parameter(i);
|
||||
auto p2 = s2->get_parameter(i);
|
||||
auto &p1 = s1->get_parameter(i);
|
||||
auto &p2 = s2->get_parameter(i);
|
||||
if (p1.is_ast() && is_sort(p1.get_ast())) {
|
||||
if (!p2.is_ast())
|
||||
return false;
|
||||
|
|
@ -282,7 +282,7 @@ namespace polymorphism {
|
|||
}
|
||||
vector<parameter> params;
|
||||
for (unsigned i = 0; i < s->get_num_parameters(); ++i) {
|
||||
parameter p = s->get_parameter(i);
|
||||
const parameter &p = s->get_parameter(i);
|
||||
if (p.is_ast() && is_sort(p.get_ast())) {
|
||||
sort_ref fs = fresh(to_sort(p.get_ast()));
|
||||
params.push_back(parameter(fs.get()));
|
||||
|
|
|
|||
|
|
@ -1235,7 +1235,7 @@ static rational symmod(rational const& a, rational const& b) {
|
|||
if (2*r > b) r -= b;
|
||||
return r;
|
||||
}
|
||||
|
||||
|
||||
br_status arith_rewriter::mk_mod_core(expr * arg1, expr * arg2, expr_ref & result) {
|
||||
set_curr_sort(arg1->get_sort());
|
||||
numeral v1, v2;
|
||||
|
|
@ -1297,9 +1297,9 @@ br_status arith_rewriter::mk_mod_core(expr * arg1, expr * arg2, expr_ref & resul
|
|||
}
|
||||
|
||||
expr* x, *y;
|
||||
if (is_num2 && v2.is_pos() && m_util.is_mul(arg1, x, y) && m_util.is_numeral(x, v1, is_int) && divides(v1, v2)) {
|
||||
result = m_util.mk_mul(x, m_util.mk_mod(y, m_util.mk_int(v2/v1)));
|
||||
return BR_REWRITE2;
|
||||
if (is_num2 && v2.is_pos() && m_util.is_mul(arg1, x, y) && m_util.is_numeral(x, v1, is_int) && v1 > 0 && divides(v1, v2)) {
|
||||
result = m_util.mk_mul(m_util.mk_int(v1), m_util.mk_mod(y, m_util.mk_int(v2/v1)));
|
||||
return BR_REWRITE1;
|
||||
}
|
||||
|
||||
if (is_num2 && v2 == 2 && m_util.is_mul(arg1, x, y)) {
|
||||
|
|
@ -1310,6 +1310,27 @@ br_status arith_rewriter::mk_mod_core(expr * arg1, expr * arg2, expr_ref & resul
|
|||
return BR_FAILED;
|
||||
}
|
||||
|
||||
bool arith_rewriter::get_range(expr* e, rational& lo, rational& hi) {
|
||||
expr* x, *y;
|
||||
rational r;
|
||||
if (m_util.is_idiv(e, x, y) && m_util.is_numeral(y, r) && get_range(x, lo, hi) && 0 <= lo && r > 0) {
|
||||
lo = div(lo, r);
|
||||
hi = div(hi, r);
|
||||
return true;
|
||||
}
|
||||
if (m_util.is_mod(e, x, y) && m_util.is_numeral(y, r) && r > 0) {
|
||||
lo = 0;
|
||||
hi = r - 1;
|
||||
return true;
|
||||
}
|
||||
if (m_util.is_numeral(e, r)) {
|
||||
lo = hi = r;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
br_status arith_rewriter::mk_rem_core(expr * arg1, expr * arg2, expr_ref & result) {
|
||||
set_curr_sort(arg1->get_sort());
|
||||
numeral v1, v2;
|
||||
|
|
@ -1454,7 +1475,7 @@ br_status arith_rewriter::mk_lshr_core(unsigned sz, expr* arg1, expr* arg2, expr
|
|||
}
|
||||
if (is_num_x && is_num_y) {
|
||||
if (y >= sz)
|
||||
result = m_util.mk_int(N-1);
|
||||
result = m_util.mk_int(0);
|
||||
else {
|
||||
rational d = div(x, rational::power_of_two(y.get_unsigned()));
|
||||
result = m_util.mk_int(d);
|
||||
|
|
|
|||
|
|
@ -63,6 +63,7 @@ class arith_rewriter : public poly_rewriter<arith_rewriter_core> {
|
|||
bool m_eq2ineq;
|
||||
unsigned m_max_degree;
|
||||
|
||||
bool get_range(expr* e, rational& lo, rational& hi);
|
||||
void get_coeffs_gcd(expr * t, numeral & g, bool & first, unsigned & num_consts);
|
||||
enum const_treatment { CT_FLOOR, CT_CEIL, CT_FALSE };
|
||||
bool div_polynomial(expr * t, numeral const & g, const_treatment ct, expr_ref & result);
|
||||
|
|
|
|||
|
|
@ -206,7 +206,9 @@ br_status array_rewriter::mk_store_core(unsigned num_args, expr * const * args,
|
|||
bool array_rewriter::squash_store(unsigned n, expr* const* args, expr_ref& result) {
|
||||
ptr_buffer<expr> parents, sargs;
|
||||
expr* a = args[0];
|
||||
while (m_util.is_store(a)) {
|
||||
unsigned rounds = 0;
|
||||
while (m_util.is_store(a) && rounds < 10) {
|
||||
++rounds;
|
||||
lbool r = compare_args(n - 2, args + 1, to_app(a)->get_args() + 1);
|
||||
switch (r) {
|
||||
case l_undef:
|
||||
|
|
|
|||
|
|
@ -615,6 +615,8 @@ MK_PARAMETRIC_UNARY_REDUCE(reduce_sign_extend, mk_sign_extend);
|
|||
if (m_blast_quant) {
|
||||
if (m_bindings.empty())
|
||||
return false;
|
||||
if (!butil().is_bv(t))
|
||||
return false;
|
||||
unsigned shift = m_shifts.back();
|
||||
if (t->get_idx() >= m_bindings.size()) {
|
||||
if (shift == 0)
|
||||
|
|
|
|||
|
|
@ -545,16 +545,9 @@ bool bool_rewriter::local_ctx_simp(unsigned num_args, expr * const * args, expr_
|
|||
bool simp = false;
|
||||
bool modified = false;
|
||||
bool forward = true;
|
||||
unsigned rounds = 0;
|
||||
expr* narg;
|
||||
|
||||
while (true) {
|
||||
rounds++;
|
||||
#if 0
|
||||
if (rounds > 10)
|
||||
verbose_stream() << "rounds: " << rounds << "\n";
|
||||
#endif
|
||||
|
||||
|
||||
#define PROCESS_ARG() \
|
||||
{ \
|
||||
|
|
@ -699,6 +692,22 @@ app* bool_rewriter::mk_eq(expr* lhs, expr* rhs) {
|
|||
return m().mk_eq(lhs, rhs);
|
||||
}
|
||||
|
||||
bool bool_rewriter::try_ite_eq(expr* lhs, expr* rhs, expr_ref& r) {
|
||||
expr* c, *t, *e;
|
||||
if (!m().is_ite(lhs, c, t, e))
|
||||
return false;
|
||||
if (m().are_equal(t, rhs) && m().are_distinct(e, rhs)) {
|
||||
r = c;
|
||||
return true;
|
||||
}
|
||||
if (m().are_equal(e, rhs) && m().are_distinct(t, rhs)) {
|
||||
r = m().mk_not(c);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
br_status bool_rewriter::mk_eq_core(expr * lhs, expr * rhs, expr_ref & result) {
|
||||
if (m().are_equal(lhs, rhs)) {
|
||||
result = m().mk_true();
|
||||
|
|
@ -713,6 +722,12 @@ br_status bool_rewriter::mk_eq_core(expr * lhs, expr * rhs, expr_ref & result) {
|
|||
br_status r = BR_FAILED;
|
||||
|
||||
|
||||
if (try_ite_eq(lhs, rhs, result))
|
||||
return BR_REWRITE1;
|
||||
|
||||
if (try_ite_eq(rhs, lhs, result))
|
||||
return BR_REWRITE1;
|
||||
|
||||
if (m_ite_extra_rules) {
|
||||
if (m().is_ite(lhs) && m().is_value(rhs)) {
|
||||
r = try_ite_value(to_app(lhs), to_app(rhs), result);
|
||||
|
|
|
|||
|
|
@ -71,6 +71,8 @@ class bool_rewriter {
|
|||
|
||||
void mk_and_as_or(unsigned num_args, expr * const * args, expr_ref & result);
|
||||
|
||||
bool try_ite_eq(expr* lhs, expr* rhs, expr_ref& r);
|
||||
|
||||
expr * mk_or_app(unsigned num_args, expr * const * args);
|
||||
bool simp_nested_not_or(unsigned num_args, expr * const * args, expr_fast_mark1 & neg_lits, expr_fast_mark2 & pos_lits, expr_ref & result);
|
||||
expr * simp_arg(expr * arg, expr_fast_mark1 & neg_lits, expr_fast_mark2 & pos_lits, bool & modified);
|
||||
|
|
|
|||
|
|
@ -20,8 +20,9 @@ Notes:
|
|||
#include "ast/rewriter/bv_rewriter.h"
|
||||
#include "ast/rewriter/poly_rewriter_def.h"
|
||||
#include "ast/rewriter/bool_rewriter.h"
|
||||
#include "ast/ast_smt2_pp.h"
|
||||
#include "ast/ast_lt.h"
|
||||
#include "ast/ast_pp.h"
|
||||
|
||||
|
||||
|
||||
void bv_rewriter::updt_local_params(params_ref const & _p) {
|
||||
|
|
@ -54,45 +55,58 @@ void bv_rewriter::get_param_descrs(param_descrs & r) {
|
|||
br_status bv_rewriter::mk_app_core(func_decl * f, unsigned num_args, expr * const * args, expr_ref & result) {
|
||||
SASSERT(f->get_family_id() == get_fid());
|
||||
|
||||
br_status st = BR_FAILED;
|
||||
switch(f->get_decl_kind()) {
|
||||
case OP_BIT0: SASSERT(num_args == 0); result = mk_zero(1); return BR_DONE;
|
||||
case OP_BIT1: SASSERT(num_args == 0); result = mk_one(1); return BR_DONE;
|
||||
case OP_ULEQ:
|
||||
SASSERT(num_args == 2);
|
||||
return mk_ule(args[0], args[1], result);
|
||||
st = mk_ule(args[0], args[1], result);
|
||||
break;
|
||||
case OP_UGEQ:
|
||||
SASSERT(num_args == 2);
|
||||
return mk_uge(args[0], args[1], result);
|
||||
st = mk_uge(args[0], args[1], result);
|
||||
break;
|
||||
case OP_ULT:
|
||||
SASSERT(num_args == 2);
|
||||
return mk_ult(args[0], args[1], result);
|
||||
st = mk_ult(args[0], args[1], result);
|
||||
break;
|
||||
case OP_UGT:
|
||||
SASSERT(num_args == 2);
|
||||
return mk_ult(args[1], args[0], result);
|
||||
st = mk_ult(args[1], args[0], result);
|
||||
break;
|
||||
case OP_SLEQ:
|
||||
SASSERT(num_args == 2);
|
||||
return mk_sle(args[0], args[1], result);
|
||||
st = mk_sle(args[0], args[1], result);
|
||||
break;
|
||||
case OP_SGEQ:
|
||||
SASSERT(num_args == 2);
|
||||
return mk_sge(args[0], args[1], result);
|
||||
st = mk_sge(args[0], args[1], result);
|
||||
break;
|
||||
case OP_SLT:
|
||||
SASSERT(num_args == 2);
|
||||
return mk_slt(args[0], args[1], result);
|
||||
st = mk_slt(args[0], args[1], result);
|
||||
break;
|
||||
case OP_SGT:
|
||||
SASSERT(num_args == 2);
|
||||
return mk_slt(args[1], args[0], result);
|
||||
st = mk_slt(args[1], args[0], result);
|
||||
break;
|
||||
case OP_BADD:
|
||||
SASSERT(num_args > 0);
|
||||
return mk_bv_add(num_args, args, result);
|
||||
st = mk_bv_add(num_args, args, result);
|
||||
break;
|
||||
case OP_BMUL:
|
||||
SASSERT(num_args > 0);
|
||||
return mk_bv_mul(num_args, args, result);
|
||||
st = mk_bv_mul(num_args, args, result);
|
||||
break;
|
||||
case OP_BSUB:
|
||||
SASSERT(num_args > 0);
|
||||
return mk_sub(num_args, args, result);
|
||||
st = mk_sub(num_args, args, result);
|
||||
break;
|
||||
case OP_BNEG:
|
||||
SASSERT(num_args == 1);
|
||||
return mk_uminus(args[0], result);
|
||||
st = mk_uminus(args[0], result);
|
||||
break;
|
||||
case OP_BNEG_OVFL:
|
||||
SASSERT(num_args == 1);
|
||||
return mk_bvneg_overflow(args[0], result);
|
||||
|
|
@ -220,6 +234,13 @@ br_status bv_rewriter::mk_app_core(func_decl * f, unsigned num_args, expr * cons
|
|||
default:
|
||||
return BR_FAILED;
|
||||
}
|
||||
|
||||
CTRACE("bv", st != BR_FAILED, tout << mk_pp(f, m) << "\n";
|
||||
for (unsigned i = 0; i < num_args; ++i)
|
||||
tout << " " << mk_bounded_pp(args[i], m) << "\n";
|
||||
tout << mk_bounded_pp(result, m, 3) << "\n");
|
||||
|
||||
return st;
|
||||
}
|
||||
|
||||
br_status bv_rewriter::mk_ule(expr * a, expr * b, expr_ref & result) {
|
||||
|
|
@ -541,7 +562,7 @@ br_status bv_rewriter::mk_leq_core(bool is_signed, expr * a, expr * b, expr_ref
|
|||
const br_status cst = rw_leq_concats(is_signed, a, b, result);
|
||||
if (cst != BR_FAILED) {
|
||||
TRACE("le_extra", tout << (is_signed ? "bv_sle\n" : "bv_ule\n")
|
||||
<< mk_ismt2_pp(a, m, 2) << "\n" << mk_ismt2_pp(b, m, 2) << "\n--->\n"<< mk_ismt2_pp(result, m, 2) << "\n";);
|
||||
<< mk_pp(a, m, 2) << "\n" << mk_pp(b, m, 2) << "\n--->\n"<< mk_pp(result, m, 2) << "\n";);
|
||||
return cst;
|
||||
}
|
||||
}
|
||||
|
|
@ -550,7 +571,7 @@ br_status bv_rewriter::mk_leq_core(bool is_signed, expr * a, expr * b, expr_ref
|
|||
const br_status cst = rw_leq_overflow(is_signed, a, b, result);
|
||||
if (cst != BR_FAILED) {
|
||||
TRACE("le_extra", tout << (is_signed ? "bv_sle\n" : "bv_ule\n")
|
||||
<< mk_ismt2_pp(a, m, 2) << "\n" << mk_ismt2_pp(b, m, 2) << "\n--->\n"<< mk_ismt2_pp(result, m, 2) << "\n";);
|
||||
<< mk_pp(a, m, 2) << "\n" << mk_pp(b, m, 2) << "\n--->\n"<< mk_pp(result, m, 2) << "\n";);
|
||||
return cst;
|
||||
}
|
||||
}
|
||||
|
|
@ -802,8 +823,8 @@ br_status bv_rewriter::mk_extract(unsigned high, unsigned low, expr * arg, expr_
|
|||
const unsigned ep_rm = propagate_extract(high, arg, ep_res);
|
||||
if (ep_rm != 0) {
|
||||
result = m_mk_extract(high, low, ep_res);
|
||||
TRACE("extract_prop", tout << mk_ismt2_pp(arg, m) << "\n[" << high <<"," << low << "]\n" << ep_rm << "---->\n"
|
||||
<< mk_ismt2_pp(result.get(), m) << "\n";);
|
||||
TRACE("extract_prop", tout << mk_pp(arg, m) << "\n[" << high <<"," << low << "]\n" << ep_rm << "---->\n"
|
||||
<< mk_pp(result.get(), m) << "\n";);
|
||||
return BR_REWRITE2;
|
||||
}
|
||||
}
|
||||
|
|
@ -1132,7 +1153,7 @@ br_status bv_rewriter::mk_bv_udiv_core(expr * arg1, expr * arg2, bool hi_div0, e
|
|||
m_util.mk_bv_udiv0(arg1),
|
||||
m_util.mk_bv_udiv_i(arg1, arg2));
|
||||
|
||||
TRACE("bv_udiv", tout << mk_ismt2_pp(arg1, m) << "\n" << mk_ismt2_pp(arg2, m) << "\n---->\n" << mk_ismt2_pp(result, m) << "\n";);
|
||||
TRACE("bv_udiv", tout << mk_pp(arg1, m) << "\n" << mk_pp(arg2, m) << "\n---->\n" << mk_pp(result, m) << "\n";);
|
||||
return BR_REWRITE2;
|
||||
}
|
||||
|
||||
|
|
@ -1792,8 +1813,8 @@ br_status bv_rewriter::mk_bv_or(unsigned num, expr * const * args, expr_ref & re
|
|||
std::reverse(exs.begin(), exs.end());
|
||||
result = m_util.mk_concat(exs.size(), exs.data());
|
||||
TRACE("mask_bug",
|
||||
tout << "(assert (distinct (bvor (_ bv" << old_v1 << " " << sz << ")\n" << mk_ismt2_pp(t, m) << ")\n";
|
||||
tout << mk_ismt2_pp(result, m) << "))\n";);
|
||||
tout << "(assert (distinct (bvor (_ bv" << old_v1 << " " << sz << ")\n" << mk_pp(t, m) << ")\n";
|
||||
tout << mk_pp(result, m) << "))\n";);
|
||||
return BR_REWRITE2;
|
||||
}
|
||||
|
||||
|
|
@ -2463,7 +2484,7 @@ br_status bv_rewriter::mk_blast_eq_value(expr * lhs, expr * rhs, expr_ref & resu
|
|||
unsigned sz = get_bv_size(lhs);
|
||||
if (sz == 1)
|
||||
return BR_FAILED;
|
||||
TRACE("blast_eq_value", tout << "sz: " << sz << "\n" << mk_ismt2_pp(lhs, m) << "\n";);
|
||||
TRACE("blast_eq_value", tout << "sz: " << sz << "\n" << mk_pp(lhs, m) << "\n";);
|
||||
if (is_numeral(lhs))
|
||||
std::swap(lhs, rhs);
|
||||
|
||||
|
|
@ -2573,7 +2594,6 @@ void bv_rewriter::mk_t1_add_t2_eq_c(expr * t1, expr * t2, expr * c, expr_ref & r
|
|||
result = m.mk_eq(t1, m_util.mk_bv_sub(c, t2));
|
||||
}
|
||||
|
||||
#include "ast/ast_pp.h"
|
||||
|
||||
bool bv_rewriter::isolate_term(expr* lhs, expr* rhs, expr_ref& result) {
|
||||
if (!m_util.is_numeral(lhs) || !is_add(rhs)) {
|
||||
|
|
@ -2730,13 +2750,13 @@ br_status bv_rewriter::mk_eq_core(expr * lhs, expr * rhs, expr_ref & result) {
|
|||
|
||||
st = mk_mul_eq(lhs, rhs, result);
|
||||
if (st != BR_FAILED) {
|
||||
TRACE("mk_mul_eq", tout << mk_ismt2_pp(lhs, m) << "\n=\n" << mk_ismt2_pp(rhs, m) << "\n----->\n" << mk_ismt2_pp(result,m) << "\n";);
|
||||
TRACE("mk_mul_eq", tout << mk_pp(lhs, m) << "\n=\n" << mk_pp(rhs, m) << "\n----->\n" << mk_pp(result,m) << "\n";);
|
||||
return st;
|
||||
}
|
||||
|
||||
st = mk_mul_eq(rhs, lhs, result);
|
||||
if (st != BR_FAILED) {
|
||||
TRACE("mk_mul_eq", tout << mk_ismt2_pp(lhs, m) << "\n=\n" << mk_ismt2_pp(rhs, m) << "\n----->\n" << mk_ismt2_pp(result,m) << "\n";);
|
||||
TRACE("mk_mul_eq", tout << mk_pp(lhs, m) << "\n=\n" << mk_pp(rhs, m) << "\n----->\n" << mk_pp(result,m) << "\n";);
|
||||
return st;
|
||||
}
|
||||
|
||||
|
|
@ -2851,8 +2871,8 @@ bool bv_rewriter::is_eq_bit(expr * t, expr * & x, unsigned & val) {
|
|||
|
||||
|
||||
br_status bv_rewriter::mk_ite_core(expr * c, expr * t, expr * e, expr_ref & result) {
|
||||
TRACE("bv_ite", tout << "mk_ite_core:\n" << mk_ismt2_pp(c, m) << "?\n"
|
||||
<< mk_ismt2_pp(t, m) << "\n:" << mk_ismt2_pp(e, m) << "\n";);
|
||||
TRACE("bv_ite", tout << "mk_ite_core:\n" << mk_pp(c, m) << "?\n"
|
||||
<< mk_pp(t, m) << "\n:" << mk_pp(e, m) << "\n";);
|
||||
if (m.are_equal(t, e)) {
|
||||
result = e;
|
||||
return BR_REWRITE1;
|
||||
|
|
|
|||
|
|
@ -157,9 +157,7 @@ expr_ref pb_rewriter::mk_validate_rewrite(app_ref& e1, app_ref& e2) {
|
|||
continue;
|
||||
}
|
||||
|
||||
std::ostringstream strm;
|
||||
strm << 'x' << i;
|
||||
name = symbol(strm.str());
|
||||
name = symbol('x' + std::to_string(i));
|
||||
trail.push_back(m.mk_const(name, a.mk_int()));
|
||||
expr* x = trail.back();
|
||||
m.is_not(e,e);
|
||||
|
|
@ -188,9 +186,7 @@ void pb_rewriter::validate_rewrite(func_decl* f, unsigned sz, expr*const* args,
|
|||
}
|
||||
|
||||
void pb_rewriter::dump_pb_rewrite(expr* fml) {
|
||||
std::ostringstream strm;
|
||||
strm << "pb_rewrite_" << (s_lemma++) << ".smt2";
|
||||
std::ofstream out(strm.str());
|
||||
std::ofstream out("pb_rewrite_" + std::to_string(s_lemma++) + ".smt2");
|
||||
ast_smt_pp pp(m());
|
||||
pp.display_smt2(out, fml);
|
||||
out.close();
|
||||
|
|
|
|||
|
|
@ -3478,7 +3478,7 @@ expr_ref seq_rewriter::mk_antimirov_deriv_union(expr* d1, expr* d2) {
|
|||
//
|
||||
// restrict(d, false) = []
|
||||
//
|
||||
// it is already assumed that the restriction takes place witin a branch
|
||||
// it is already assumed that the restriction takes place within a branch
|
||||
// so the condition is not added explicitly but propagated down in order to eliminate
|
||||
// infeasible cases
|
||||
expr_ref seq_rewriter::mk_antimirov_deriv_restrict(expr* e, expr* d, expr* cond) {
|
||||
|
|
@ -3717,7 +3717,7 @@ expr_ref seq_rewriter::mk_regex_concat(expr* r, expr* s) {
|
|||
result = re().mk_plus(re().mk_full_char(ele_sort));
|
||||
else if (re().is_concat(r, r1, r2))
|
||||
// create the resulting concatenation in right-associative form except for the following case
|
||||
// TODO: maintain the followig invariant for A ++ B{m,n} + C
|
||||
// TODO: maintain the following invariant for A ++ B{m,n} + C
|
||||
// concat(concat(A, B{m,n}), C) (if A != () and C != ())
|
||||
// concat(B{m,n}, C) (if A == () and C != ())
|
||||
// where A, B, C are regexes
|
||||
|
|
@ -3725,11 +3725,11 @@ expr_ref seq_rewriter::mk_regex_concat(expr* r, expr* s) {
|
|||
// In other words, do not make A ++ B{m,n} into right-assoc form, but keep B{m,n} at the top
|
||||
// This will help to identify this situation in the merge routine:
|
||||
// concat(concat(A, B{0,m}), C) | concat(concat(A, B{0,n}), C)
|
||||
// simplies to
|
||||
// simplifies to
|
||||
// concat(concat(A, B{0,max(m,n)}), C)
|
||||
// analogously:
|
||||
// concat(concat(A, B{0,m}), C) & concat(concat(A, B{0,n}), C)
|
||||
// simplies to
|
||||
// simplifies to
|
||||
// concat(concat(A, B{0,min(m,n)}), C)
|
||||
result = mk_regex_concat(r1, mk_regex_concat(r2, s));
|
||||
else {
|
||||
|
|
@ -3850,12 +3850,12 @@ bool seq_rewriter::pred_implies(expr* a, expr* b) {
|
|||
Utility function to decide if two BDDs (nested if-then-else terms)
|
||||
have exactly the same structure and conditions.
|
||||
*/
|
||||
bool seq_rewriter::ite_bdds_compatabile(expr* a, expr* b) {
|
||||
bool seq_rewriter::ite_bdds_compatible(expr* a, expr* b) {
|
||||
expr* ca = nullptr, *a1 = nullptr, *a2 = nullptr;
|
||||
expr* cb = nullptr, *b1 = nullptr, *b2 = nullptr;
|
||||
if (m().is_ite(a, ca, a1, a2) && m().is_ite(b, cb, b1, b2)) {
|
||||
return (ca == cb) && ite_bdds_compatabile(a1, b1)
|
||||
&& ite_bdds_compatabile(a2, b2);
|
||||
return (ca == cb) && ite_bdds_compatible(a1, b1)
|
||||
&& ite_bdds_compatible(a2, b2);
|
||||
}
|
||||
else if (m().is_ite(a) || m().is_ite(b)) {
|
||||
return false;
|
||||
|
|
@ -3915,7 +3915,7 @@ expr_ref seq_rewriter::mk_der_op_rec(decl_kind k, expr* a, expr* b) {
|
|||
// sophisticated: in an antimirov union of n terms, we really
|
||||
// want to check if any pair of them is compatible.
|
||||
else if (m().is_ite(a) && m().is_ite(b) &&
|
||||
!ite_bdds_compatabile(a, b)) {
|
||||
!ite_bdds_compatible(a, b)) {
|
||||
k = _OP_RE_ANTIMIROV_UNION;
|
||||
}
|
||||
#endif
|
||||
|
|
@ -4269,7 +4269,7 @@ expr_ref seq_rewriter::mk_derivative_rec(expr* ele, expr* r) {
|
|||
}
|
||||
else if (re().is_reverse(r, r1)) {
|
||||
if (re().is_to_re(r1, r2)) {
|
||||
// First try to exctract hd and tl such that r = hd ++ tl and |tl|=1
|
||||
// First try to extract hd and tl such that r = hd ++ tl and |tl|=1
|
||||
expr_ref hd(m()), tl(m());
|
||||
if (get_head_tail_reversed(r2, hd, tl)) {
|
||||
// Use mk_der_cond to normalize
|
||||
|
|
|
|||
|
|
@ -201,7 +201,7 @@ class seq_rewriter {
|
|||
expr_ref mk_der_compl(expr* a);
|
||||
expr_ref mk_der_cond(expr* cond, expr* ele, sort* seq_sort);
|
||||
expr_ref mk_der_antimirov_union(expr* r1, expr* r2);
|
||||
bool ite_bdds_compatabile(expr* a, expr* b);
|
||||
bool ite_bdds_compatible(expr* a, expr* b);
|
||||
/* if r has the form deriv(en..deriv(e1,to_re(s))..) returns 's = [e1..en]' else returns '() in r'*/
|
||||
expr_ref is_nullable_symbolic_regex(expr* r, sort* seq_sort);
|
||||
#ifdef Z3DEBUG
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@ Module Name:
|
|||
Abstract:
|
||||
|
||||
Skolem function support for sequences.
|
||||
Skolem functions are auxiliary funcions useful for axiomatizing sequence
|
||||
Skolem functions are auxiliary functions useful for axiomatizing sequence
|
||||
operations.
|
||||
|
||||
Author:
|
||||
|
|
|
|||
|
|
@ -66,7 +66,6 @@ bool elim_unconstrained::is_var_lt(int v1, int v2) const {
|
|||
}
|
||||
|
||||
void elim_unconstrained::eliminate() {
|
||||
|
||||
while (!m_heap.empty()) {
|
||||
expr_ref r(m);
|
||||
int v = m_heap.erase_min();
|
||||
|
|
@ -86,7 +85,12 @@ void elim_unconstrained::eliminate() {
|
|||
n.m_refcount = 0;
|
||||
continue;
|
||||
}
|
||||
if (m_heap.contains(root(e))) {
|
||||
IF_VERBOSE(11, verbose_stream() << "already in heap " << mk_bounded_pp(e, m) << "\n");
|
||||
continue;
|
||||
}
|
||||
app* t = to_app(e);
|
||||
TRACE("elim_unconstrained", tout << "eliminating " << mk_pp(t, m) << "\n";);
|
||||
unsigned sz = m_args.size();
|
||||
for (expr* arg : *to_app(t))
|
||||
m_args.push_back(reconstruct_term(get_node(arg)));
|
||||
|
|
@ -99,14 +103,17 @@ void elim_unconstrained::eliminate() {
|
|||
proof * pr = m.mk_apply_def(s, r, pr1);
|
||||
m_trail.push_back(pr);
|
||||
}
|
||||
expr_ref rr(m.mk_app(t->get_decl(), t->get_num_args(), m_args.data() + sz), m);
|
||||
n.m_refcount = 0;
|
||||
m_args.shrink(sz);
|
||||
if (!inverted) {
|
||||
IF_VERBOSE(11, verbose_stream() << "not inverted " << mk_bounded_pp(e, m) << "\n");
|
||||
continue;
|
||||
}
|
||||
|
||||
IF_VERBOSE(11, verbose_stream() << "replace " << mk_pp(t, m) << " / " << rr << " -> " << r << "\n");
|
||||
|
||||
TRACE("elim_unconstrained", tout << mk_pp(t, m) << " -> " << r << "\n");
|
||||
TRACE("elim_unconstrained", tout << mk_pp(t, m) << " / " << rr << " -> " << r << "\n");
|
||||
SASSERT(r->get_sort() == t->get_sort());
|
||||
m_stats.m_num_eliminated++;
|
||||
m_trail.push_back(r);
|
||||
|
|
@ -119,7 +126,8 @@ void elim_unconstrained::eliminate() {
|
|||
get_node(e).m_term = r;
|
||||
get_node(e).m_proof = pr;
|
||||
get_node(e).m_refcount++;
|
||||
IF_VERBOSE(11, verbose_stream() << mk_bounded_pp(e, m) << "\n");
|
||||
get_node(e).m_dirty = false;
|
||||
IF_VERBOSE(11, verbose_stream() << "set " << &get_node(e) << " " << root(e) << " " << mk_bounded_pp(e, m) << " := " << mk_bounded_pp(r, m) << "\n");
|
||||
SASSERT(!m_heap.contains(root(e)));
|
||||
if (is_uninterp_const(r))
|
||||
m_heap.insert(root(e));
|
||||
|
|
@ -263,12 +271,18 @@ void elim_unconstrained::gc(expr* t) {
|
|||
while (!todo.empty()) {
|
||||
t = todo.back();
|
||||
todo.pop_back();
|
||||
|
||||
node& n = get_node(t);
|
||||
if (n.m_refcount == 0)
|
||||
continue;
|
||||
if (n.m_term && !is_node(n.m_term))
|
||||
continue;
|
||||
|
||||
dec_ref(t);
|
||||
if (n.m_refcount != 0)
|
||||
continue;
|
||||
if (n.m_term)
|
||||
t = n.m_term;
|
||||
if (is_app(t)) {
|
||||
for (expr* arg : *to_app(t))
|
||||
todo.push_back(arg);
|
||||
|
|
@ -283,13 +297,22 @@ expr_ref elim_unconstrained::reconstruct_term(node& n0) {
|
|||
expr* t = n0.m_term;
|
||||
if (!n0.m_dirty)
|
||||
return expr_ref(t, m);
|
||||
if (!is_node(t))
|
||||
return expr_ref(t, m);
|
||||
ptr_vector<expr> todo;
|
||||
todo.push_back(t);
|
||||
while (!todo.empty()) {
|
||||
t = todo.back();
|
||||
if (!is_node(t)) {
|
||||
UNREACHABLE();
|
||||
}
|
||||
node& n = get_node(t);
|
||||
unsigned sz0 = todo.size();
|
||||
if (is_app(t)) {
|
||||
if (is_app(t)) {
|
||||
if (n.m_term != t) {
|
||||
todo.pop_back();
|
||||
continue;
|
||||
}
|
||||
for (expr* arg : *to_app(t))
|
||||
if (get_node(arg).m_dirty || !get_node(arg).m_term)
|
||||
todo.push_back(arg);
|
||||
|
|
@ -300,7 +323,6 @@ expr_ref elim_unconstrained::reconstruct_term(node& n0) {
|
|||
for (expr* arg : *to_app(t))
|
||||
m_args.push_back(get_node(arg).m_term);
|
||||
n.m_term = m.mk_app(to_app(t)->get_decl(), to_app(t)->get_num_args(), m_args.data() + sz);
|
||||
|
||||
m_args.shrink(sz);
|
||||
}
|
||||
else if (is_quantifier(t)) {
|
||||
|
|
@ -418,6 +440,6 @@ void elim_unconstrained::reduce() {
|
|||
vector<dependent_expr> old_fmls;
|
||||
assert_normalized(old_fmls);
|
||||
update_model_trail(*mc, old_fmls);
|
||||
mc->reset();
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -182,11 +182,11 @@ std::ostream& model_reconstruction_trail::display(std::ostream& out) const {
|
|||
out << "hide " << t->m_decl->get_name() << "\n";
|
||||
else if (t->is_def()) {
|
||||
for (auto const& [f, def, dep] : t->m_defs)
|
||||
out << f->get_name() << " <- " << mk_pp(def, m) << "\n";
|
||||
out << "def: " << f->get_name() << " <- " << mk_pp(def, m) << "\n";
|
||||
}
|
||||
else {
|
||||
for (auto const& [v, def] : t->m_subst->sub())
|
||||
out << mk_pp(v, m) << " <- " << mk_pp(def, m) << "\n";
|
||||
out << "sub: " << mk_pp(v, m) << " -> " << mk_pp(def, m) << "\n";
|
||||
}
|
||||
for (auto const& d : t->m_removed)
|
||||
out << "rm: " << d << "\n";
|
||||
|
|
|
|||
9
src/ast/sls/CMakeLists.txt
Normal file
9
src/ast/sls/CMakeLists.txt
Normal file
|
|
@ -0,0 +1,9 @@
|
|||
z3_add_component(ast_sls
|
||||
SOURCES
|
||||
bvsls_opt_engine.cpp
|
||||
sls_engine.cpp
|
||||
COMPONENT_DEPENDENCIES
|
||||
ast
|
||||
converters
|
||||
normal_forms
|
||||
)
|
||||
369
src/ast/sls/bvsls_opt_engine.cpp
Normal file
369
src/ast/sls/bvsls_opt_engine.cpp
Normal file
|
|
@ -0,0 +1,369 @@
|
|||
/*++
|
||||
Copyright (c) 2014 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
bvsls_opt_engine.cpp
|
||||
|
||||
Abstract:
|
||||
|
||||
Optimization extensions to bvsls
|
||||
|
||||
Author:
|
||||
|
||||
Christoph (cwinter) 2014-03-28
|
||||
|
||||
Notes:
|
||||
|
||||
--*/
|
||||
#include "ast/normal_forms/nnf.h"
|
||||
#include "ast/sls/bvsls_opt_engine.h"
|
||||
|
||||
bvsls_opt_engine::bvsls_opt_engine(ast_manager & m, params_ref const & p) :
|
||||
sls_engine(m, p),
|
||||
m_hard_tracker(sls_engine::m_tracker),
|
||||
m_obj_tracker(m, m_bv_util, m_mpz_manager, m_powers),
|
||||
m_obj_evaluator(m, m_bv_util, m_obj_tracker, m_mpz_manager, m_powers)
|
||||
{
|
||||
m_best_model = alloc(model, m);
|
||||
}
|
||||
|
||||
bvsls_opt_engine::~bvsls_opt_engine()
|
||||
{
|
||||
}
|
||||
|
||||
bvsls_opt_engine::optimization_result bvsls_opt_engine::optimize(
|
||||
expr_ref const & objective,
|
||||
model_ref initial_model,
|
||||
bool _maximize)
|
||||
{
|
||||
SASSERT(m_bv_util.is_bv(objective));
|
||||
TRACE("sls_opt", tout << "objective: " << (_maximize?"maximize":"minimize") << " " <<
|
||||
mk_ismt2_pp(objective, m()) << std::endl;);
|
||||
m_hard_tracker.initialize(m_assertions);
|
||||
setup_opt_tracker(objective, _maximize);
|
||||
|
||||
if (initial_model.get() != nullptr) {
|
||||
TRACE("sls_opt", tout << "Initial model provided: " << std::endl;
|
||||
for (unsigned i = 0; i < initial_model->get_num_constants(); i++) {
|
||||
func_decl * fd = initial_model->get_constant(i);
|
||||
expr * val = initial_model->get_const_interp(fd);
|
||||
tout << fd->get_name() << " := " << mk_ismt2_pp(val, m()) << std::endl;
|
||||
});
|
||||
m_hard_tracker.set_model(initial_model);
|
||||
m_evaluator.update_all();
|
||||
}
|
||||
|
||||
optimization_result res(m_manager);
|
||||
lbool is_sat = m_hard_tracker.is_sat() ? l_true : l_undef;
|
||||
|
||||
TRACE("sls_opt", tout << "initial model is sat? " << is_sat << std::endl;);
|
||||
|
||||
for (m_stats.m_restarts = 0;
|
||||
m_stats.m_restarts < m_max_restarts;
|
||||
m_stats.m_restarts++)
|
||||
{
|
||||
mpz old_best;
|
||||
m_mpz_manager.set(old_best, m_best_model_score);
|
||||
|
||||
if (is_sat != l_true) {
|
||||
do {
|
||||
if (!m_manager.inc())
|
||||
return res;
|
||||
|
||||
IF_VERBOSE(1, verbose_stream() << "Satisfying... restarts left:" << (m_max_restarts - m_stats.m_restarts) << std::endl;);
|
||||
is_sat = search();
|
||||
|
||||
if (is_sat == l_undef)
|
||||
m_hard_tracker.randomize(m_assertions);
|
||||
}
|
||||
while (is_sat != l_true &&
|
||||
m_stats.m_restarts++ < m_max_restarts);
|
||||
}
|
||||
|
||||
if (is_sat == l_true) {
|
||||
IF_VERBOSE(1, verbose_stream() << "Optimizing... restarts left:" << (m_max_restarts - m_stats.m_restarts) << std::endl;);
|
||||
res.is_sat = l_true;
|
||||
m_obj_tracker.set_model(m_hard_tracker.get_model());
|
||||
m_obj_evaluator.update_all();
|
||||
expr_ref local_best = maximize();
|
||||
if ((_maximize && m_mpz_manager.gt(m_best_model_score, old_best)) ||
|
||||
(!_maximize && m_mpz_manager.lt(m_best_model_score, old_best)))
|
||||
{
|
||||
res.optimum = local_best;
|
||||
}
|
||||
}
|
||||
|
||||
m_hard_tracker.randomize(m_assertions);
|
||||
m_evaluator.update_all();
|
||||
is_sat = m_hard_tracker.is_sat() ? l_true : l_undef;
|
||||
}
|
||||
|
||||
TRACE("sls_opt", tout << "sat: " << res.is_sat << "; optimum: " << mk_ismt2_pp(res.optimum, m()) << std::endl;);
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
void bvsls_opt_engine::setup_opt_tracker(expr_ref const & objective, bool _max)
|
||||
{
|
||||
expr_ref obj(m_manager);
|
||||
obj = objective;
|
||||
if (!_max)
|
||||
obj = m_bv_util.mk_bv_neg(objective);
|
||||
|
||||
m_obj_e = obj.get();
|
||||
m_obj_bv_sz = m_bv_util.get_bv_size(m_obj_e);
|
||||
ptr_vector<expr> objs;
|
||||
objs.push_back(m_obj_e);
|
||||
m_obj_tracker.initialize(objs);
|
||||
}
|
||||
|
||||
expr_ref bvsls_opt_engine::maximize()
|
||||
{
|
||||
SASSERT(m_hard_tracker.is_sat());
|
||||
|
||||
TRACE("sls_opt", tout << "Initial opt model:" << std::endl; m_obj_tracker.show_model(tout););
|
||||
|
||||
mpz score, old_score, max_score, new_value;
|
||||
unsigned new_const = (unsigned)-1, new_bit = 0;
|
||||
ptr_vector<func_decl> consts = m_obj_tracker.get_constants();
|
||||
move_type move;
|
||||
m_mpz_manager.set(score, top_score());
|
||||
m_mpz_manager.set(max_score, m_powers(m_obj_bv_sz)); m_mpz_manager.dec(max_score);
|
||||
|
||||
IF_VERBOSE(10, verbose_stream() << "Initial score: " << m_mpz_manager.to_string(score) << std::endl;);
|
||||
|
||||
save_model(score);
|
||||
|
||||
while (m_mpz_manager.lt(score, max_score) && check_restart(m_stats.m_moves))
|
||||
{
|
||||
if (!m_manager.inc())
|
||||
goto bailout;
|
||||
m_stats.m_moves++;
|
||||
m_mpz_manager.set(old_score, score);
|
||||
new_const = (unsigned)-1;
|
||||
|
||||
mpz score(0);
|
||||
m_mpz_manager.set(score,
|
||||
find_best_move(consts, score, new_const, new_value, new_bit, move, max_score, m_obj_e));
|
||||
|
||||
if (new_const == static_cast<unsigned>(-1)) {
|
||||
m_mpz_manager.set(score, old_score);
|
||||
if (m_mpz_manager.gt(score, m_best_model_score))
|
||||
save_model(score);
|
||||
if (!randomize_wrt_hard()) {
|
||||
// Can't improve and can't randomize; can't do anything other than bail out.
|
||||
TRACE("sls_opt", tout << "Got stuck; bailing out." << std::endl;);
|
||||
IF_VERBOSE(10, verbose_stream() << "No local improvements possible." << std::endl;);
|
||||
goto bailout;
|
||||
}
|
||||
m_mpz_manager.set(score, top_score());
|
||||
}
|
||||
else {
|
||||
m_stats.m_moves++;
|
||||
TRACE("sls_opt", tout << "New optimum: " << m_mpz_manager.to_string(score) << std::endl;);
|
||||
IF_VERBOSE(10, verbose_stream() << "New optimum: " << m_mpz_manager.to_string(score) << std::endl;);
|
||||
func_decl * fd = consts[new_const];
|
||||
incremental_score(fd, new_value);
|
||||
m_obj_evaluator.update(fd, new_value);
|
||||
m_mpz_manager.set(score, top_score());
|
||||
}
|
||||
}
|
||||
|
||||
bailout:
|
||||
m_mpz_manager.del(new_value);
|
||||
|
||||
expr_ref res(m_manager);
|
||||
res = m_bv_util.mk_numeral(m_best_model_score, m_obj_bv_sz);
|
||||
return res;
|
||||
}
|
||||
|
||||
void bvsls_opt_engine::save_model(mpz const & score) {
|
||||
model_ref mdl = m_hard_tracker.get_model();
|
||||
model_ref obj_mdl = m_obj_tracker.get_model();
|
||||
|
||||
for (unsigned i = 0; i < obj_mdl->get_num_constants(); i++) {
|
||||
func_decl * fd = obj_mdl->get_constant(i);
|
||||
expr * val = obj_mdl->get_const_interp(fd);
|
||||
if (mdl->has_interpretation(fd)) {
|
||||
if (mdl->get_const_interp(fd) != val)
|
||||
TRACE("sls_opt", tout << "model disagreement on " << fd->get_name() << ": " <<
|
||||
mk_ismt2_pp(val, m()) << " != " << mk_ismt2_pp(mdl->get_const_interp(fd), m()) << std::endl;);
|
||||
SASSERT(mdl->get_const_interp(fd) == val);
|
||||
}
|
||||
else
|
||||
mdl->register_decl(fd, val);
|
||||
}
|
||||
|
||||
m_best_model = mdl;
|
||||
m_mpz_manager.set(m_best_model_score, score);
|
||||
}
|
||||
|
||||
// checks whether the score outcome of a given move is better than the previous score
|
||||
bool bvsls_opt_engine::what_if(
|
||||
func_decl * fd,
|
||||
const unsigned & fd_inx,
|
||||
const mpz & temp,
|
||||
mpz & best_score,
|
||||
unsigned & best_const,
|
||||
mpz & best_value)
|
||||
{
|
||||
#if _EARLY_PRUNE_
|
||||
double r = incremental_score_prune(fd, temp);
|
||||
#else
|
||||
double r = incremental_score(fd, temp);
|
||||
#endif
|
||||
|
||||
if (r >= 1.0 && m_hard_tracker.is_sat()) {
|
||||
m_obj_evaluator.update(fd, temp);
|
||||
mpz cur_best(0);
|
||||
m_mpz_manager.set(cur_best, top_score());
|
||||
|
||||
TRACE("sls_whatif", tout << "WHAT IF " << fd->get_name() << " WERE " << m_mpz_manager.to_string(temp) <<
|
||||
" --> " << r << "; score=" << m_mpz_manager.to_string(cur_best) << std::endl;);
|
||||
|
||||
if (m_mpz_manager.gt(cur_best, best_score)) {
|
||||
m_mpz_manager.set(best_score, cur_best);
|
||||
best_const = fd_inx;
|
||||
m_mpz_manager.set(best_value, temp);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
TRACE("sls_whatif_failed", tout << "WHAT IF " << fd->get_name() << " WERE " << m_mpz_manager.to_string(temp) <<
|
||||
" --> unsatisfied hard constraints" << std::endl;);
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
mpz bvsls_opt_engine::find_best_move(
|
||||
ptr_vector<func_decl> & to_evaluate,
|
||||
mpz & score,
|
||||
unsigned & best_const,
|
||||
mpz & best_value,
|
||||
unsigned & new_bit,
|
||||
move_type & move,
|
||||
mpz const & max_score,
|
||||
expr * objective)
|
||||
{
|
||||
mpz old_value, temp;
|
||||
#if _USE_MUL3_ || _USE_UNARY_MINUS_
|
||||
mpz temp2;
|
||||
#endif
|
||||
unsigned bv_sz;
|
||||
mpz new_score;
|
||||
m_mpz_manager.set(new_score, score);
|
||||
|
||||
for (unsigned i = 0; i < to_evaluate.size() && m_mpz_manager.lt(new_score, max_score); i++) {
|
||||
func_decl * fd = to_evaluate[i];
|
||||
sort * srt = fd->get_range();
|
||||
bv_sz = (m_manager.is_bool(srt)) ? 1 : m_bv_util.get_bv_size(srt);
|
||||
m_mpz_manager.set(old_value, m_obj_tracker.get_value(fd));
|
||||
|
||||
// first try to flip every bit
|
||||
for (unsigned j = 0; j < bv_sz && m_mpz_manager.lt(new_score, max_score); j++) {
|
||||
// What would happen if we flipped bit #i ?
|
||||
mk_flip(srt, old_value, j, temp);
|
||||
|
||||
if (what_if(fd, i, temp, new_score, best_const, best_value)) {
|
||||
new_bit = j;
|
||||
move = MV_FLIP;
|
||||
}
|
||||
}
|
||||
|
||||
if (m_bv_util.is_bv_sort(srt) && bv_sz > 1) {
|
||||
#if _USE_ADDSUB_
|
||||
if (!m_mpz_manager.is_even(old_value)) {
|
||||
// for odd values, try +1
|
||||
mk_inc(bv_sz, old_value, temp);
|
||||
if (what_if(fd, i, temp, new_score, best_const, best_value))
|
||||
move = MV_INC;
|
||||
}
|
||||
else {
|
||||
// for even values, try -1
|
||||
mk_dec(bv_sz, old_value, temp);
|
||||
if (what_if(fd, i, temp, new_score, best_const, best_value))
|
||||
move = MV_DEC;
|
||||
}
|
||||
#endif
|
||||
// try inverting
|
||||
mk_inv(bv_sz, old_value, temp);
|
||||
if (what_if(fd, i, temp, new_score, best_const, best_value))
|
||||
move = MV_INV;
|
||||
|
||||
#if _USE_UNARY_MINUS_
|
||||
mk_inc(bv_sz, temp, temp2);
|
||||
if (what_if(fd, i, temp2, new_score, best_const, best_value))
|
||||
move = MV_UMIN;
|
||||
#endif
|
||||
|
||||
#if _USE_MUL2DIV2_
|
||||
// try multiplication by 2
|
||||
mk_mul2(bv_sz, old_value, temp);
|
||||
if (what_if(fd, i, temp, new_score, best_const, best_value))
|
||||
move = MV_MUL2;
|
||||
|
||||
#if _USE_MUL3_
|
||||
// try multiplication by 3
|
||||
mk_add(bv_sz, old_value, temp, temp2);
|
||||
if (what_if(fd, i, temp2, new_score, best_const, best_value))
|
||||
move = MV_MUL3;
|
||||
#endif
|
||||
|
||||
// try division by 2
|
||||
mk_div2(bv_sz, old_value, temp);
|
||||
if (what_if(fd, i, temp, new_score, best_const, best_value))
|
||||
move = MV_DIV2;
|
||||
#endif
|
||||
}
|
||||
|
||||
// reset to what it was before
|
||||
//double check =
|
||||
incremental_score(fd, old_value);
|
||||
m_obj_evaluator.update(fd, old_value);
|
||||
}
|
||||
|
||||
m_mpz_manager.del(old_value);
|
||||
m_mpz_manager.del(temp);
|
||||
#if _USE_MUL3_
|
||||
m_mpz_manager.del(temp2);
|
||||
#endif
|
||||
|
||||
return new_score;
|
||||
}
|
||||
|
||||
bool bvsls_opt_engine::randomize_wrt_hard() {
|
||||
ptr_vector<func_decl> consts = m_obj_tracker.get_constants();
|
||||
unsigned csz = consts.size();
|
||||
unsigned retry_count = csz;
|
||||
|
||||
while (retry_count-- > 0)
|
||||
{
|
||||
|
||||
unsigned ri = (m_obj_tracker.get_random_uint((csz < 16) ? 4 : (csz < 256) ? 8 : (csz < 4096) ? 12 : (csz < 65536) ? 16 : 32)) % csz;
|
||||
func_decl * random_fd = consts[ri]; // Random constant
|
||||
|
||||
mpz random_val; // random value.
|
||||
m_mpz_manager.set(random_val, m_obj_tracker.get_random(random_fd->get_range()));
|
||||
|
||||
mpz old_value;
|
||||
m_mpz_manager.set(old_value, m_obj_tracker.get_value(random_fd));
|
||||
|
||||
if (!m_mpz_manager.eq(random_val, old_value)) {
|
||||
m_evaluator.update(random_fd, random_val);
|
||||
|
||||
if (m_hard_tracker.is_sat()) {
|
||||
TRACE("sls_opt", tout << "Randomizing " << random_fd->get_name() << " to " <<
|
||||
m_mpz_manager.to_string(random_val) << std::endl;);
|
||||
m_obj_evaluator.update(random_fd, random_val);
|
||||
return true;
|
||||
}
|
||||
else
|
||||
m_evaluator.update(random_fd, old_value);
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
71
src/ast/sls/bvsls_opt_engine.h
Normal file
71
src/ast/sls/bvsls_opt_engine.h
Normal file
|
|
@ -0,0 +1,71 @@
|
|||
/*++
|
||||
Copyright (c) 2014 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
bvsls_opt_engine.h
|
||||
|
||||
Abstract:
|
||||
|
||||
Optimization extensions to bvsls
|
||||
|
||||
Author:
|
||||
|
||||
Christoph (cwinter) 2014-03-28
|
||||
|
||||
Notes:
|
||||
|
||||
--*/
|
||||
#pragma once
|
||||
|
||||
#include "ast/sls/sls_engine.h"
|
||||
|
||||
class bvsls_opt_engine : public sls_engine {
|
||||
sls_tracker & m_hard_tracker;
|
||||
sls_tracker m_obj_tracker;
|
||||
sls_evaluator m_obj_evaluator;
|
||||
model_ref m_best_model;
|
||||
mpz m_best_model_score;
|
||||
unsigned m_obj_bv_sz;
|
||||
expr * m_obj_e;
|
||||
|
||||
public:
|
||||
bvsls_opt_engine(ast_manager & m, params_ref const & p);
|
||||
~bvsls_opt_engine();
|
||||
|
||||
class optimization_result {
|
||||
public:
|
||||
lbool is_sat;
|
||||
expr_ref optimum;
|
||||
optimization_result(ast_manager & m) : is_sat(l_undef), optimum(m) {}
|
||||
};
|
||||
|
||||
optimization_result optimize(expr_ref const & objective, model_ref initial_model = model_ref(), bool maximize=true);
|
||||
|
||||
void get_model(model_ref & result) { result = m_best_model; }
|
||||
|
||||
protected:
|
||||
void setup_opt_tracker(expr_ref const & objective, bool _max);
|
||||
expr_ref maximize();
|
||||
|
||||
bool what_if(func_decl * fd, const unsigned & fd_inx, const mpz & temp,
|
||||
mpz & best_score, unsigned & best_const, mpz & best_value);
|
||||
|
||||
mpz find_best_move(ptr_vector<func_decl> & to_evaluate, mpz & score,
|
||||
unsigned & best_const, mpz & best_value, unsigned & new_bit, move_type & move,
|
||||
mpz const & max_score, expr * objective);
|
||||
|
||||
mpz top_score() {
|
||||
mpz res(0);
|
||||
obj_hashtable<expr> const & top_exprs = m_obj_tracker.get_top_exprs();
|
||||
for (obj_hashtable<expr>::iterator it = top_exprs.begin();
|
||||
it != top_exprs.end();
|
||||
it++)
|
||||
m_mpz_manager.add(res, m_obj_tracker.get_value(*it), res);
|
||||
return res;
|
||||
}
|
||||
|
||||
void save_model(mpz const & score);
|
||||
bool randomize_wrt_hard();
|
||||
};
|
||||
|
||||
591
src/ast/sls/sls_engine.cpp
Normal file
591
src/ast/sls/sls_engine.cpp
Normal file
|
|
@ -0,0 +1,591 @@
|
|||
/*++
|
||||
Copyright (c) 2012 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
sls_engine.cpp
|
||||
|
||||
Abstract:
|
||||
|
||||
A Stochastic Local Search (SLS) engine
|
||||
|
||||
Author:
|
||||
|
||||
Christoph (cwinter) 2014-03-19
|
||||
|
||||
Notes:
|
||||
|
||||
--*/
|
||||
#include<float.h> // Need DBL_MAX
|
||||
|
||||
#include "util/map.h"
|
||||
#include "ast/ast_smt2_pp.h"
|
||||
#include "ast/ast_pp.h"
|
||||
#include "ast/rewriter/var_subst.h"
|
||||
#include "model/model_pp.h"
|
||||
#include "util/luby.h"
|
||||
|
||||
#include "params/sls_params.hpp"
|
||||
#include "ast/sls/sls_engine.h"
|
||||
|
||||
|
||||
sls_engine::sls_engine(ast_manager & m, params_ref const & p) :
|
||||
m_manager(m),
|
||||
m_powers(m_mpz_manager),
|
||||
m_zero(m_mpz_manager.mk_z(0)),
|
||||
m_one(m_mpz_manager.mk_z(1)),
|
||||
m_two(m_mpz_manager.mk_z(2)),
|
||||
m_bv_util(m),
|
||||
m_tracker(m, m_bv_util, m_mpz_manager, m_powers),
|
||||
m_evaluator(m, m_bv_util, m_tracker, m_mpz_manager, m_powers)
|
||||
{
|
||||
updt_params(p);
|
||||
m_tracker.updt_params(p);
|
||||
}
|
||||
|
||||
sls_engine::~sls_engine() {
|
||||
m_mpz_manager.del(m_zero);
|
||||
m_mpz_manager.del(m_one);
|
||||
m_mpz_manager.del(m_two);
|
||||
}
|
||||
|
||||
void sls_engine::updt_params(params_ref const & _p) {
|
||||
sls_params p(_p);
|
||||
m_max_restarts = p.max_restarts();
|
||||
m_tracker.set_random_seed(p.random_seed());
|
||||
m_walksat = p.walksat();
|
||||
m_walksat_repick = p.walksat_repick();
|
||||
m_paws_sp = p.paws_sp();
|
||||
m_paws = m_paws_sp < 1024;
|
||||
m_wp = p.wp();
|
||||
m_vns_mc = p.vns_mc();
|
||||
m_vns_repick = p.vns_repick();
|
||||
|
||||
m_restart_base = p.restart_base();
|
||||
m_restart_next = m_restart_base;
|
||||
m_restart_init = p.restart_init();
|
||||
|
||||
m_early_prune = p.early_prune();
|
||||
m_random_offset = p.random_offset();
|
||||
m_rescore = p.rescore();
|
||||
|
||||
// Andreas: Would cause trouble because repick requires an assertion being picked before which is not the case in GSAT.
|
||||
if (m_walksat_repick && !m_walksat)
|
||||
NOT_IMPLEMENTED_YET();
|
||||
if (m_vns_repick && !m_walksat)
|
||||
NOT_IMPLEMENTED_YET();
|
||||
}
|
||||
|
||||
void sls_engine::collect_statistics(statistics& st) const {
|
||||
double seconds = m_stats.m_stopwatch.get_current_seconds();
|
||||
st.update("sls restarts", m_stats.m_restarts);
|
||||
st.update("sls full evals", m_stats.m_full_evals);
|
||||
st.update("sls incr evals", m_stats.m_incr_evals);
|
||||
st.update("sls incr evals/sec", m_stats.m_incr_evals / seconds);
|
||||
st.update("sls FLIP moves", m_stats.m_flips);
|
||||
st.update("sls INC moves", m_stats.m_incs);
|
||||
st.update("sls DEC moves", m_stats.m_decs);
|
||||
st.update("sls INV moves", m_stats.m_invs);
|
||||
st.update("sls moves", m_stats.m_moves);
|
||||
st.update("sls moves/sec", m_stats.m_moves / seconds);
|
||||
}
|
||||
|
||||
|
||||
bool sls_engine::full_eval(model & mdl) {
|
||||
model::scoped_model_completion _scm(mdl, true);
|
||||
for (expr* a : m_assertions) {
|
||||
if (!m_manager.inc())
|
||||
return false;
|
||||
if (!mdl.is_true(a)) {
|
||||
TRACE("sls", tout << "Evaluation: false\n";);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
double sls_engine::top_score() {
|
||||
double top_sum = 0.0;
|
||||
for (expr* e : m_assertions) {
|
||||
top_sum += m_tracker.get_score(e);
|
||||
}
|
||||
|
||||
TRACE("sls_top", tout << "Score distribution:";
|
||||
for (expr* e : m_assertions)
|
||||
tout << " " << m_tracker.get_score(e);
|
||||
tout << " AVG: " << top_sum / (double)m_assertions.size() << std::endl;);
|
||||
|
||||
m_tracker.set_top_sum(top_sum);
|
||||
|
||||
return top_sum;
|
||||
}
|
||||
|
||||
double sls_engine::rescore() {
|
||||
m_evaluator.update_all();
|
||||
m_stats.m_full_evals++;
|
||||
return top_score();
|
||||
}
|
||||
|
||||
double sls_engine::serious_score(func_decl * fd, const mpz & new_value) {
|
||||
m_evaluator.serious_update(fd, new_value);
|
||||
m_stats.m_incr_evals++;
|
||||
return m_tracker.get_top_sum();
|
||||
}
|
||||
|
||||
double sls_engine::incremental_score(func_decl * fd, const mpz & new_value) {
|
||||
m_evaluator.update(fd, new_value);
|
||||
m_stats.m_incr_evals++;
|
||||
return m_tracker.get_top_sum();
|
||||
}
|
||||
|
||||
double sls_engine::incremental_score_prune(func_decl * fd, const mpz & new_value) {
|
||||
m_stats.m_incr_evals++;
|
||||
if (m_evaluator.update_prune(fd, new_value))
|
||||
return m_tracker.get_top_sum();
|
||||
else
|
||||
return -DBL_MAX;
|
||||
}
|
||||
|
||||
// checks whether the score outcome of a given move is better than the previous score
|
||||
bool sls_engine::what_if(
|
||||
func_decl * fd,
|
||||
const unsigned & fd_inx,
|
||||
const mpz & temp,
|
||||
double & best_score,
|
||||
unsigned & best_const,
|
||||
mpz & best_value) {
|
||||
|
||||
#ifdef Z3DEBUG
|
||||
mpz old_value;
|
||||
m_mpz_manager.set(old_value, m_tracker.get_value(fd));
|
||||
#endif
|
||||
|
||||
double r;
|
||||
if (m_early_prune)
|
||||
r = incremental_score_prune(fd, temp);
|
||||
else
|
||||
r = incremental_score(fd, temp);
|
||||
#ifdef Z3DEBUG
|
||||
TRACE("sls_whatif", tout << "WHAT IF " << fd->get_name() << " WERE " << m_mpz_manager.to_string(temp) <<
|
||||
" --> " << r << std::endl;);
|
||||
|
||||
m_mpz_manager.del(old_value);
|
||||
#endif
|
||||
|
||||
// Andreas: Had this idea on my last day. Maybe we could add a noise here similar to the one that worked so well for ucb assertion selection.
|
||||
// r += 0.0001 * m_tracker.get_random_uint(8);
|
||||
|
||||
// Andreas: For some reason it is important to use > here instead of >=. Probably related to preferring the LSB.
|
||||
if (r > best_score) {
|
||||
best_score = r;
|
||||
best_const = fd_inx;
|
||||
m_mpz_manager.set(best_value, temp);
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
void sls_engine::mk_add(unsigned bv_sz, const mpz & old_value, mpz & add_value, mpz & result) {
|
||||
mpz temp, mask, mask2;
|
||||
m_mpz_manager.add(old_value, add_value, temp);
|
||||
m_mpz_manager.set(mask, m_powers(bv_sz));
|
||||
m_mpz_manager.bitwise_not(bv_sz, mask, mask2);
|
||||
m_mpz_manager.bitwise_and(temp, mask2, result);
|
||||
m_mpz_manager.del(temp);
|
||||
m_mpz_manager.del(mask);
|
||||
m_mpz_manager.del(mask2);
|
||||
|
||||
}
|
||||
|
||||
void sls_engine::mk_inc(unsigned bv_sz, const mpz & old_value, mpz & incremented) {
|
||||
unsigned shift;
|
||||
m_mpz_manager.add(old_value, m_one, incremented);
|
||||
if (m_mpz_manager.is_power_of_two(incremented, shift) && shift == bv_sz)
|
||||
m_mpz_manager.set(incremented, m_zero);
|
||||
}
|
||||
|
||||
void sls_engine::mk_dec(unsigned bv_sz, const mpz & old_value, mpz & decremented) {
|
||||
if (m_mpz_manager.is_zero(old_value)) {
|
||||
m_mpz_manager.set(decremented, m_powers(bv_sz));
|
||||
m_mpz_manager.dec(decremented);
|
||||
}
|
||||
else
|
||||
m_mpz_manager.sub(old_value, m_one, decremented);
|
||||
}
|
||||
|
||||
void sls_engine::mk_inv(unsigned bv_sz, const mpz & old_value, mpz & inverted) {
|
||||
m_mpz_manager.bitwise_not(bv_sz, old_value, inverted);
|
||||
}
|
||||
|
||||
void sls_engine::mk_flip(sort * s, const mpz & old_value, unsigned bit, mpz & flipped) {
|
||||
m_mpz_manager.set(flipped, m_zero);
|
||||
|
||||
if (m_bv_util.is_bv_sort(s)) {
|
||||
mpz mask;
|
||||
m_mpz_manager.set(mask, m_powers(bit));
|
||||
m_mpz_manager.bitwise_xor(old_value, mask, flipped);
|
||||
m_mpz_manager.del(mask);
|
||||
}
|
||||
else if (m_manager.is_bool(s))
|
||||
m_mpz_manager.set(flipped, (m_mpz_manager.is_zero(old_value)) ? m_one : m_zero);
|
||||
else
|
||||
NOT_IMPLEMENTED_YET();
|
||||
}
|
||||
|
||||
void sls_engine::mk_random_move(ptr_vector<func_decl> & unsat_constants)
|
||||
{
|
||||
unsigned rnd_mv = 0;
|
||||
unsigned ucc = unsat_constants.size();
|
||||
unsigned rc = (m_tracker.get_random_uint((ucc < 16) ? 4 : (ucc < 256) ? 8 : (ucc < 4096) ? 12 : (ucc < 65536) ? 16 : 32)) % ucc;
|
||||
func_decl * fd = unsat_constants[rc];
|
||||
|
||||
mpz new_value;
|
||||
|
||||
sort * srt = fd->get_range();
|
||||
if (m_manager.is_bool(srt))
|
||||
m_mpz_manager.set(new_value, (m_mpz_manager.is_zero(m_tracker.get_value(fd))) ? m_one : m_zero);
|
||||
else
|
||||
{
|
||||
if (m_mpz_manager.is_one(m_tracker.get_random_bool())) rnd_mv = 2;
|
||||
if (m_mpz_manager.is_one(m_tracker.get_random_bool())) rnd_mv++;
|
||||
|
||||
// Andreas: The other option would be to scale the probability for flips according to the bit-width.
|
||||
/* unsigned bv_sz2 = m_bv_util.get_bv_size(srt);
|
||||
rnd_mv = m_tracker.get_random_uint(16) % (bv_sz2 + 3);
|
||||
if (rnd_mv > 3) rnd_mv = 0; */
|
||||
|
||||
move_type mt = (move_type)rnd_mv;
|
||||
|
||||
// Andreas: Christoph claimed inversion doesn't make sense, let's do a flip instead. Is this really true?
|
||||
if (mt == MV_INV) mt = MV_FLIP;
|
||||
unsigned bit = 0;
|
||||
|
||||
switch (mt)
|
||||
{
|
||||
case MV_FLIP: {
|
||||
unsigned bv_sz = m_bv_util.get_bv_size(srt);
|
||||
bit = (m_tracker.get_random_uint((bv_sz < 16) ? 4 : (bv_sz < 256) ? 8 : (bv_sz < 4096) ? 12 : (bv_sz < 65536) ? 16 : 32)) % bv_sz;
|
||||
mk_flip(fd->get_range(), m_tracker.get_value(fd), bit, new_value);
|
||||
break;
|
||||
}
|
||||
case MV_INC:
|
||||
mk_inc(m_bv_util.get_bv_size(fd->get_range()), m_tracker.get_value(fd), new_value);
|
||||
break;
|
||||
case MV_DEC:
|
||||
mk_dec(m_bv_util.get_bv_size(fd->get_range()), m_tracker.get_value(fd), new_value);
|
||||
break;
|
||||
case MV_INV:
|
||||
mk_inv(m_bv_util.get_bv_size(fd->get_range()), m_tracker.get_value(fd), new_value);
|
||||
break;
|
||||
default:
|
||||
NOT_IMPLEMENTED_YET();
|
||||
}
|
||||
|
||||
TRACE("sls", tout << "Randomization candidates: ";
|
||||
for (unsigned i = 0; i < unsat_constants.size(); i++)
|
||||
tout << unsat_constants[i]->get_name() << ", ";
|
||||
tout << std::endl;
|
||||
tout << "Random move: ";
|
||||
switch (mt) {
|
||||
case MV_FLIP: tout << "Flip #" << bit << " in " << fd->get_name() << std::endl; break;
|
||||
case MV_INC: tout << "+1 for " << fd->get_name() << std::endl; break;
|
||||
case MV_DEC: tout << "-1 for " << fd->get_name() << std::endl; break;
|
||||
case MV_INV: tout << "NEG for " << fd->get_name() << std::endl; break;
|
||||
}
|
||||
tout << "Locally randomized model: " << std::endl; m_tracker.show_model(tout););
|
||||
}
|
||||
|
||||
m_evaluator.serious_update(fd, new_value);
|
||||
m_mpz_manager.del(new_value);
|
||||
}
|
||||
|
||||
// finds the move that increased score the most. returns best_const = -1, if no increasing move exists.
|
||||
double sls_engine::find_best_move(
|
||||
ptr_vector<func_decl> & to_evaluate,
|
||||
double score,
|
||||
unsigned & best_const,
|
||||
mpz & best_value,
|
||||
unsigned & new_bit,
|
||||
move_type & move)
|
||||
{
|
||||
mpz old_value, temp;
|
||||
unsigned bv_sz;
|
||||
double new_score = score;
|
||||
|
||||
// Andreas: Introducting a bit of randomization by using a random offset and a random direction to go through the candidate list.
|
||||
unsigned sz = to_evaluate.size();
|
||||
unsigned offset = (m_random_offset) ? m_tracker.get_random_uint(16) % sz : 0;
|
||||
for (unsigned j = 0; j < sz; j++) {
|
||||
unsigned i = j + offset;
|
||||
if (i >= sz) i -= sz;
|
||||
//for (unsigned i = 0; i < to_evaluate.size(); i++) {
|
||||
func_decl * fd = to_evaluate[i];
|
||||
sort * srt = fd->get_range();
|
||||
bv_sz = (m_manager.is_bool(srt)) ? 1 : m_bv_util.get_bv_size(srt);
|
||||
m_mpz_manager.set(old_value, m_tracker.get_value(fd));
|
||||
|
||||
// first try to flip every bit
|
||||
for (unsigned j = 0; j < bv_sz; j++) {
|
||||
// What would happen if we flipped bit #i ?
|
||||
mk_flip(srt, old_value, j, temp);
|
||||
|
||||
if (what_if(fd, i, temp, new_score, best_const, best_value)) {
|
||||
new_bit = j;
|
||||
move = MV_FLIP;
|
||||
}
|
||||
}
|
||||
|
||||
if (m_bv_util.is_bv_sort(srt) && bv_sz > 1) {
|
||||
if (!m_mpz_manager.is_even(old_value)) {
|
||||
// for odd values, try +1
|
||||
mk_inc(bv_sz, old_value, temp);
|
||||
if (what_if(fd, i, temp, new_score, best_const, best_value))
|
||||
move = MV_INC;
|
||||
}
|
||||
else {
|
||||
// for even values, try -1
|
||||
mk_dec(bv_sz, old_value, temp);
|
||||
if (what_if(fd, i, temp, new_score, best_const, best_value))
|
||||
move = MV_DEC;
|
||||
}
|
||||
// try inverting
|
||||
mk_inv(bv_sz, old_value, temp);
|
||||
if (what_if(fd, i, temp, new_score, best_const, best_value))
|
||||
move = MV_INV;
|
||||
}
|
||||
// reset to what it was before
|
||||
incremental_score(fd, old_value);
|
||||
}
|
||||
|
||||
m_mpz_manager.del(old_value);
|
||||
m_mpz_manager.del(temp);
|
||||
|
||||
return new_score;
|
||||
}
|
||||
|
||||
// finds the move that increased score the most. returns best_const = -1, if no increasing move exists.
|
||||
double sls_engine::find_best_move_mc(ptr_vector<func_decl> & to_evaluate, double score,
|
||||
unsigned & best_const, mpz & best_value) {
|
||||
mpz old_value, temp, temp2;
|
||||
unsigned bv_sz;
|
||||
double new_score = score;
|
||||
|
||||
// Andreas: Introducting a bit of randomization by using a random offset and a random direction to go through the candidate list.
|
||||
unsigned sz = to_evaluate.size();
|
||||
unsigned offset = (m_random_offset) ? m_tracker.get_random_uint(16) % sz : 0;
|
||||
for (unsigned j = 0; j < sz; j++) {
|
||||
unsigned i = j + offset;
|
||||
if (i >= sz) i -= sz;
|
||||
//for (unsigned i = 0; i < to_evaluate.size(); i++) {
|
||||
func_decl * fd = to_evaluate[i];
|
||||
sort * srt = fd->get_range();
|
||||
bv_sz = (m_manager.is_bool(srt)) ? 1 : m_bv_util.get_bv_size(srt);
|
||||
m_mpz_manager.set(old_value, m_tracker.get_value(fd));
|
||||
|
||||
if (m_bv_util.is_bv_sort(srt) && bv_sz > 2) {
|
||||
for (unsigned j = 0; j < bv_sz; j++) {
|
||||
mk_flip(srt, old_value, j, temp);
|
||||
for (unsigned l = 0; l < m_vns_mc && l < bv_sz / 2; l++)
|
||||
{
|
||||
unsigned k = m_tracker.get_random_uint(16) % bv_sz;
|
||||
while (k == j)
|
||||
k = m_tracker.get_random_uint(16) % bv_sz;
|
||||
mk_flip(srt, temp, k, temp2);
|
||||
what_if(fd, i, temp2, new_score, best_const, best_value);
|
||||
}
|
||||
}
|
||||
}
|
||||
// reset to what it was before
|
||||
incremental_score(fd, old_value);
|
||||
}
|
||||
|
||||
m_mpz_manager.del(old_value);
|
||||
m_mpz_manager.del(temp);
|
||||
m_mpz_manager.del(temp2);
|
||||
|
||||
return new_score;
|
||||
}
|
||||
|
||||
// main search loop
|
||||
lbool sls_engine::search() {
|
||||
lbool res = l_undef;
|
||||
double score = 0.0, old_score = 0.0;
|
||||
unsigned new_const = (unsigned)-1, new_bit;
|
||||
mpz new_value;
|
||||
move_type move;
|
||||
|
||||
score = rescore();
|
||||
unsigned sz = m_assertions.size();
|
||||
|
||||
while (check_restart(m_stats.m_moves)) {
|
||||
if (!m_manager.inc())
|
||||
return l_undef;
|
||||
m_stats.m_moves++;
|
||||
|
||||
// Andreas: Every base restart interval ...
|
||||
if (m_stats.m_moves % m_restart_base == 0)
|
||||
{
|
||||
// ... potentially smooth the touched counters ...
|
||||
m_tracker.ucb_forget(m_assertions);
|
||||
// ... or normalize the top-level score.
|
||||
if (m_rescore) score = rescore();
|
||||
}
|
||||
|
||||
// get candidate variables
|
||||
ptr_vector<func_decl> & to_evaluate = m_tracker.get_unsat_constants(m_assertions);
|
||||
if (to_evaluate.empty())
|
||||
{
|
||||
res = l_true;
|
||||
goto bailout;
|
||||
}
|
||||
|
||||
// random walk with probability wp / 1024
|
||||
if (m_wp && m_tracker.get_random_uint(10) < m_wp)
|
||||
{
|
||||
mk_random_move(to_evaluate);
|
||||
score = m_tracker.get_top_sum();
|
||||
continue;
|
||||
}
|
||||
|
||||
old_score = score;
|
||||
new_const = (unsigned)-1;
|
||||
|
||||
// find best increasing move
|
||||
score = find_best_move(to_evaluate, score, new_const, new_value, new_bit, move);
|
||||
|
||||
// use Monte Carlo 2-bit-flip sampling if no increasing move was found previously
|
||||
if (m_vns_mc && (new_const == static_cast<unsigned>(-1)))
|
||||
score = find_best_move_mc(to_evaluate, score, new_const, new_value);
|
||||
|
||||
// repick assertion if no increasing move was found previously
|
||||
if (m_vns_repick && (new_const == static_cast<unsigned>(-1)))
|
||||
{
|
||||
expr * q = m_tracker.get_new_unsat_assertion(m_assertions);
|
||||
// only apply if another unsatisfied assertion actually exists
|
||||
if (q)
|
||||
{
|
||||
ptr_vector<func_decl> & to_evaluate2 = m_tracker.get_unsat_constants_walksat(q);
|
||||
score = find_best_move(to_evaluate2, score, new_const, new_value, new_bit, move);
|
||||
|
||||
if (new_const != static_cast<unsigned>(-1)) {
|
||||
func_decl * fd = to_evaluate2[new_const];
|
||||
score = serious_score(fd, new_value);
|
||||
continue;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// randomize if no increasing move was found
|
||||
if (new_const == static_cast<unsigned>(-1)) {
|
||||
score = old_score;
|
||||
if (m_walksat_repick)
|
||||
m_evaluator.randomize_local(m_assertions);
|
||||
else
|
||||
m_evaluator.randomize_local(to_evaluate);
|
||||
|
||||
score = m_tracker.get_top_sum();
|
||||
|
||||
// update assertion weights if a weighting is enabled (sp < 1024)
|
||||
if (m_paws)
|
||||
{
|
||||
for (unsigned i = 0; i < sz; i++)
|
||||
{
|
||||
expr * q = m_assertions[i];
|
||||
// smooth weights with probability sp / 1024
|
||||
if (m_tracker.get_random_uint(10) < m_paws_sp)
|
||||
{
|
||||
if (m_mpz_manager.eq(m_tracker.get_value(q),m_one))
|
||||
m_tracker.decrease_weight(q);
|
||||
}
|
||||
// increase weights otherwise
|
||||
else
|
||||
{
|
||||
if (m_mpz_manager.eq(m_tracker.get_value(q),m_zero))
|
||||
m_tracker.increase_weight(q);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
// otherwise, apply most increasing move
|
||||
else {
|
||||
func_decl * fd = to_evaluate[new_const];
|
||||
score = serious_score(fd, new_value);
|
||||
}
|
||||
}
|
||||
|
||||
bailout:
|
||||
m_mpz_manager.del(new_value);
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
|
||||
lbool sls_engine::operator()() {
|
||||
m_tracker.initialize(m_assertions);
|
||||
m_tracker.reset(m_assertions);
|
||||
if (m_restart_init)
|
||||
m_tracker.randomize(m_assertions);
|
||||
|
||||
lbool res = l_undef;
|
||||
|
||||
do {
|
||||
if (!m_manager.inc())
|
||||
return l_undef;
|
||||
|
||||
// report_tactic_progress("Searching... restarts left:", m_max_restarts - m_stats.m_restarts);
|
||||
res = search();
|
||||
|
||||
if (res == l_undef)
|
||||
{
|
||||
if (m_restart_init)
|
||||
m_tracker.randomize(m_assertions);
|
||||
else
|
||||
m_tracker.reset(m_assertions);
|
||||
}
|
||||
} while (res != l_true && m_stats.m_restarts++ < m_max_restarts);
|
||||
|
||||
verbose_stream() << "(restarts: " << m_stats.m_restarts << " flips: " << m_stats.m_moves << " fps: " << (m_stats.m_moves / m_stats.m_stopwatch.get_current_seconds()) << ")" << std::endl;
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
/* Andreas: Needed for Armin's restart scheme if we don't want to use loops.
|
||||
double sls_engine::get_restart_armin(unsigned cnt_restarts)
|
||||
{
|
||||
unsigned outer_id = (unsigned)(0.5 + sqrt(0.25 + 2 * cnt_restarts));
|
||||
unsigned inner_id = cnt_restarts - (outer_id - 1) * outer_id / 2;
|
||||
return pow((double) _RESTART_CONST_ARMIN_, (int) inner_id + 1);
|
||||
}
|
||||
*/
|
||||
|
||||
unsigned sls_engine::check_restart(unsigned curr_value)
|
||||
{
|
||||
if (curr_value > m_restart_next)
|
||||
{
|
||||
/* Andreas: My own scheme (= 1) seems to work best. Other schemes are disabled so that we save one parameter.
|
||||
I leave the other versions as comments in case you want to try it again somewhen.
|
||||
#if _RESTART_SCHEME_ == 5
|
||||
m_restart_next += (unsigned)(m_restart_base * pow(_RESTART_CONST_ARMIN_, m_stats.m_restarts));
|
||||
#elif _RESTART_SCHEME_ == 4
|
||||
m_restart_next += (m_stats.m_restarts & (m_stats.m_restarts + 1)) ? m_restart_base : (m_restart_base * m_stats.m_restarts + 1);
|
||||
#elif _RESTART_SCHEME_ == 3
|
||||
m_restart_next += (unsigned)get_restart_armin(m_stats.m_restarts + 1) * m_restart_base;
|
||||
#elif _RESTART_SCHEME_ == 2
|
||||
m_restart_next += get_luby(m_stats.m_restarts + 1) * m_restart_base;
|
||||
#elif _RESTART_SCHEME_ == 1
|
||||
if (m_stats.m_restarts & 1)
|
||||
m_restart_next += m_restart_base;
|
||||
else
|
||||
m_restart_next += (2 << (m_stats.m_restarts >> 1)) * m_restart_base;
|
||||
#else
|
||||
m_restart_limit += m_restart_base;
|
||||
#endif */
|
||||
if (m_stats.m_restarts & 1)
|
||||
m_restart_next += m_restart_base;
|
||||
else
|
||||
m_restart_next += (2 << (m_stats.m_restarts >> 1)) * m_restart_base;
|
||||
return 0;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
143
src/ast/sls/sls_engine.h
Normal file
143
src/ast/sls/sls_engine.h
Normal file
|
|
@ -0,0 +1,143 @@
|
|||
/*++
|
||||
Copyright (c) 2014 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
sls_engine.h
|
||||
|
||||
Abstract:
|
||||
|
||||
A Stochastic Local Search (SLS) engine
|
||||
|
||||
Author:
|
||||
|
||||
Christoph (cwinter) 2014-03-19
|
||||
|
||||
Notes:
|
||||
|
||||
--*/
|
||||
#pragma once
|
||||
|
||||
#include "util/stopwatch.h"
|
||||
#include "util/lbool.h"
|
||||
#include "ast/converters/model_converter.h"
|
||||
|
||||
#include "ast/sls/sls_tracker.h"
|
||||
#include "ast/sls/sls_evaluator.h"
|
||||
#include "util/statistics.h"
|
||||
|
||||
class sls_engine {
|
||||
public:
|
||||
class stats {
|
||||
public:
|
||||
unsigned m_restarts;
|
||||
stopwatch m_stopwatch;
|
||||
unsigned m_full_evals;
|
||||
unsigned m_incr_evals;
|
||||
unsigned m_moves, m_flips, m_incs, m_decs, m_invs;
|
||||
|
||||
stats() :
|
||||
m_restarts(0),
|
||||
m_full_evals(0),
|
||||
m_incr_evals(0),
|
||||
m_moves(0),
|
||||
m_flips(0),
|
||||
m_incs(0),
|
||||
m_decs(0),
|
||||
m_invs(0) {
|
||||
m_stopwatch.reset();
|
||||
m_stopwatch.start();
|
||||
}
|
||||
void reset() {
|
||||
m_full_evals = m_flips = m_incr_evals = 0;
|
||||
m_stopwatch.reset();
|
||||
m_stopwatch.start();
|
||||
}
|
||||
};
|
||||
|
||||
protected:
|
||||
ast_manager & m_manager;
|
||||
stats m_stats;
|
||||
unsynch_mpz_manager m_mpz_manager;
|
||||
powers m_powers;
|
||||
mpz m_zero, m_one, m_two;
|
||||
bv_util m_bv_util;
|
||||
sls_tracker m_tracker;
|
||||
sls_evaluator m_evaluator;
|
||||
ptr_vector<expr> m_assertions;
|
||||
|
||||
unsigned m_max_restarts;
|
||||
unsigned m_walksat;
|
||||
unsigned m_walksat_repick;
|
||||
unsigned m_wp;
|
||||
unsigned m_vns_mc;
|
||||
unsigned m_vns_repick;
|
||||
unsigned m_paws;
|
||||
unsigned m_paws_sp;
|
||||
unsigned m_restart_base;
|
||||
unsigned m_restart_next;
|
||||
unsigned m_restart_init;
|
||||
unsigned m_early_prune;
|
||||
unsigned m_random_offset;
|
||||
unsigned m_rescore;
|
||||
|
||||
typedef enum { MV_FLIP = 0, MV_INC, MV_DEC, MV_INV } move_type;
|
||||
|
||||
public:
|
||||
sls_engine(ast_manager & m, params_ref const & p);
|
||||
~sls_engine();
|
||||
|
||||
ast_manager & m() const { return m_manager; }
|
||||
|
||||
|
||||
void updt_params(params_ref const & _p);
|
||||
|
||||
void assert_expr(expr * e) { m_assertions.push_back(e); }
|
||||
|
||||
stats const & get_stats(void) { return m_stats; }
|
||||
void collect_statistics(statistics & st) const;
|
||||
void reset_statistics() { m_stats.reset(); }
|
||||
|
||||
bool full_eval(model & mdl);
|
||||
|
||||
void mk_add(unsigned bv_sz, const mpz & old_value, mpz & add_value, mpz & result);
|
||||
void mk_inc(unsigned bv_sz, const mpz & old_value, mpz & incremented);
|
||||
void mk_dec(unsigned bv_sz, const mpz & old_value, mpz & decremented);
|
||||
void mk_inv(unsigned bv_sz, const mpz & old_value, mpz & inverted);
|
||||
void mk_flip(sort * s, const mpz & old_value, unsigned bit, mpz & flipped);
|
||||
|
||||
lbool search();
|
||||
|
||||
lbool operator()();
|
||||
|
||||
mpz & get_value(expr * n) { return m_tracker.get_value(n); }
|
||||
|
||||
model_ref get_model() { return m_tracker.get_model(); }
|
||||
|
||||
unsynch_mpz_manager& get_mpz_manager() { return m_mpz_manager; }
|
||||
|
||||
protected:
|
||||
|
||||
bool what_if(func_decl * fd, const unsigned & fd_inx, const mpz & temp,
|
||||
double & best_score, unsigned & best_const, mpz & best_value);
|
||||
|
||||
double top_score();
|
||||
double rescore();
|
||||
double serious_score(func_decl * fd, const mpz & new_value);
|
||||
double incremental_score(func_decl * fd, const mpz & new_value);
|
||||
|
||||
double incremental_score_prune(func_decl * fd, const mpz & new_value);
|
||||
double find_best_move(ptr_vector<func_decl> & to_evaluate, double score,
|
||||
unsigned & best_const, mpz & best_value, unsigned & new_bit, move_type & move);
|
||||
|
||||
double find_best_move_mc(ptr_vector<func_decl> & to_evaluate, double score,
|
||||
unsigned & best_const, mpz & best_value);
|
||||
|
||||
void mk_random_move(ptr_vector<func_decl> & unsat_constants);
|
||||
|
||||
//double get_restart_armin(unsigned cnt_restarts);
|
||||
unsigned check_restart(unsigned curr_value);
|
||||
|
||||
|
||||
};
|
||||
|
||||
821
src/ast/sls/sls_evaluator.h
Normal file
821
src/ast/sls/sls_evaluator.h
Normal file
|
|
@ -0,0 +1,821 @@
|
|||
/*++
|
||||
Copyright (c) 2012 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
sls_evaluator.h
|
||||
|
||||
Abstract:
|
||||
|
||||
SLS Evaluator
|
||||
|
||||
Author:
|
||||
|
||||
Christoph (cwinter) 2012-02-29
|
||||
|
||||
Notes:
|
||||
|
||||
--*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "model/model_evaluator.h"
|
||||
|
||||
#include "ast/sls/sls_powers.h"
|
||||
#include "ast/sls/sls_tracker.h"
|
||||
|
||||
class sls_evaluator {
|
||||
ast_manager & m_manager;
|
||||
bv_util & m_bv_util;
|
||||
family_id m_basic_fid;
|
||||
family_id m_bv_fid;
|
||||
sls_tracker & m_tracker;
|
||||
unsynch_mpz_manager & m_mpz_manager;
|
||||
mpz m_zero, m_one, m_two;
|
||||
powers & m_powers;
|
||||
expr_ref_buffer m_temp_exprs;
|
||||
vector<ptr_vector<expr> > m_traversal_stack;
|
||||
vector<ptr_vector<expr> > m_traversal_stack_bool;
|
||||
|
||||
public:
|
||||
sls_evaluator(ast_manager & m, bv_util & bvu, sls_tracker & t, unsynch_mpz_manager & mm, powers & p) :
|
||||
m_manager(m),
|
||||
m_bv_util(bvu),
|
||||
m_tracker(t),
|
||||
m_mpz_manager(mm),
|
||||
m_zero(m_mpz_manager.mk_z(0)),
|
||||
m_one(m_mpz_manager.mk_z(1)),
|
||||
m_two(m_mpz_manager.mk_z(2)),
|
||||
m_powers(p),
|
||||
m_temp_exprs(m) {
|
||||
m_bv_fid = m_bv_util.get_family_id();
|
||||
m_basic_fid = m_manager.get_basic_family_id();
|
||||
}
|
||||
|
||||
~sls_evaluator() {
|
||||
m_mpz_manager.del(m_zero);
|
||||
m_mpz_manager.del(m_one);
|
||||
m_mpz_manager.del(m_two);
|
||||
}
|
||||
|
||||
void operator()(app * n, mpz & result) {
|
||||
family_id nfid = n->get_family_id();
|
||||
func_decl * fd = n->get_decl();
|
||||
unsigned n_args = n->get_num_args();
|
||||
|
||||
if (n_args == 0) {
|
||||
m_mpz_manager.set(result, m_tracker.get_value(n));
|
||||
return;
|
||||
}
|
||||
|
||||
expr * const * args = n->get_args();
|
||||
|
||||
m_mpz_manager.set(result, m_zero);
|
||||
|
||||
if (nfid == m_basic_fid) {
|
||||
switch (n->get_decl_kind()) {
|
||||
case OP_AND: {
|
||||
m_mpz_manager.set(result, m_one);
|
||||
for (unsigned i = 0; i < n_args; i++)
|
||||
if (m_mpz_manager.neq(m_tracker.get_value(args[i]), result)) {
|
||||
m_mpz_manager.set(result, m_zero);
|
||||
break;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case OP_OR: {
|
||||
for (unsigned i = 0; i < n_args; i++)
|
||||
if (m_mpz_manager.neq(m_tracker.get_value(args[i]), result)) {
|
||||
m_mpz_manager.set(result, m_one);
|
||||
break;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case OP_NOT: {
|
||||
SASSERT(n_args == 1);
|
||||
const mpz & child = m_tracker.get_value(args[0]);
|
||||
SASSERT(m_mpz_manager.is_one(child) || m_mpz_manager.is_zero(child));
|
||||
m_mpz_manager.set(result, (m_mpz_manager.is_zero(child)) ? m_one : m_zero);
|
||||
break;
|
||||
}
|
||||
case OP_EQ: {
|
||||
SASSERT(n_args >= 2);
|
||||
m_mpz_manager.set(result, m_one);
|
||||
const mpz & first = m_tracker.get_value(args[0]);
|
||||
for (unsigned i = 1; i < n_args; i++)
|
||||
if (m_mpz_manager.neq(m_tracker.get_value(args[i]), first)) {
|
||||
m_mpz_manager.set(result, m_zero);
|
||||
break;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case OP_DISTINCT: {
|
||||
m_mpz_manager.set(result, m_one);
|
||||
for (unsigned i = 0; i < n_args && m_mpz_manager.is_one(result); i++) {
|
||||
for (unsigned j = i+1; j < n_args && m_mpz_manager.is_one(result); j++) {
|
||||
if (m_mpz_manager.eq(m_tracker.get_value(args[i]), m_tracker.get_value(args[j])))
|
||||
m_mpz_manager.set(result, m_zero);
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
case OP_ITE: {
|
||||
SASSERT(n_args = 3);
|
||||
if (m_mpz_manager.is_one(m_tracker.get_value(args[0])))
|
||||
m_mpz_manager.set(result, m_tracker.get_value(args[1]));
|
||||
else
|
||||
m_mpz_manager.set(result, m_tracker.get_value(args[2]));
|
||||
break;
|
||||
}
|
||||
default:
|
||||
NOT_IMPLEMENTED_YET();
|
||||
}
|
||||
}
|
||||
else if (nfid == m_bv_fid) {
|
||||
bv_op_kind k = static_cast<bv_op_kind>(fd->get_decl_kind());
|
||||
switch(k) {
|
||||
case OP_CONCAT: {
|
||||
SASSERT(n_args >= 2);
|
||||
for (unsigned i = 0; i < n_args; i++) {
|
||||
if (i != 0) {
|
||||
const mpz & p = m_powers(m_bv_util.get_bv_size(args[i]));
|
||||
m_mpz_manager.mul(result, p, result);
|
||||
}
|
||||
m_mpz_manager.add(result, m_tracker.get_value(args[i]), result);
|
||||
}
|
||||
break;
|
||||
}
|
||||
case OP_EXTRACT: {
|
||||
SASSERT(n_args == 1);
|
||||
const mpz & child = m_tracker.get_value(args[0]);
|
||||
unsigned h = m_bv_util.get_extract_high(n);
|
||||
unsigned l = m_bv_util.get_extract_low(n);
|
||||
|
||||
m_mpz_manager.rem(child, m_powers(h+1), result); // result = [h:0] of child
|
||||
m_mpz_manager.machine_div2k(result, l, result);
|
||||
break;
|
||||
}
|
||||
case OP_BADD: {
|
||||
SASSERT(n_args >= 2);
|
||||
for (unsigned i = 0; i < n_args; i++) {
|
||||
const mpz & next = m_tracker.get_value(args[i]);
|
||||
m_mpz_manager.add(result, next, result);
|
||||
}
|
||||
const mpz & p = m_powers(m_bv_util.get_bv_size(n));
|
||||
m_mpz_manager.rem(result, p, result);
|
||||
break;
|
||||
}
|
||||
case OP_BSUB: {
|
||||
SASSERT(n_args == 2);
|
||||
const mpz & p = m_powers(m_bv_util.get_bv_size(n));
|
||||
mpz temp;
|
||||
m_mpz_manager.sub(m_tracker.get_value(args[0]), m_tracker.get_value(args[1]), temp);
|
||||
m_mpz_manager.mod(temp, p, result);
|
||||
m_mpz_manager.del(temp);
|
||||
break;
|
||||
}
|
||||
case OP_BMUL: {
|
||||
SASSERT(n_args >= 2);
|
||||
m_mpz_manager.set(result, m_tracker.get_value(args[0]));
|
||||
for (unsigned i = 1; i < n_args; i++) {
|
||||
const mpz & next = m_tracker.get_value(args[i]);
|
||||
m_mpz_manager.mul(result, next, result);
|
||||
}
|
||||
const mpz & p = m_powers(m_bv_util.get_bv_size(n));
|
||||
m_mpz_manager.rem(result, p, result);
|
||||
break;
|
||||
}
|
||||
case OP_BNEG: { // 2's complement unary minus
|
||||
SASSERT(n_args == 1);
|
||||
const mpz & child = m_tracker.get_value(args[0]);
|
||||
if (m_mpz_manager.is_zero(child)) {
|
||||
m_mpz_manager.set(result, m_zero);
|
||||
}
|
||||
else {
|
||||
unsigned bv_sz = m_bv_util.get_bv_size(n);
|
||||
m_mpz_manager.bitwise_not(bv_sz, child, result);
|
||||
m_mpz_manager.inc(result); // can't overflow
|
||||
}
|
||||
break;
|
||||
}
|
||||
case OP_BSDIV:
|
||||
case OP_BSDIV0:
|
||||
case OP_BSDIV_I: {
|
||||
SASSERT(n_args == 2);
|
||||
mpz x; m_mpz_manager.set(x, m_tracker.get_value(args[0]));
|
||||
mpz y; m_mpz_manager.set(y, m_tracker.get_value(args[1]));
|
||||
SASSERT(m_mpz_manager.is_nonneg(x) && m_mpz_manager.is_nonneg(y));
|
||||
unsigned bv_sz = m_bv_util.get_bv_size(args[0]);
|
||||
const mpz & p = m_powers(bv_sz);
|
||||
const mpz & p_half = m_powers(bv_sz-1);
|
||||
if (x >= p_half) { m_mpz_manager.sub(x, p, x); }
|
||||
if (y >= p_half) { m_mpz_manager.sub(y, p, y); }
|
||||
|
||||
if (m_mpz_manager.is_zero(y)) {
|
||||
if (m_mpz_manager.is_neg(x))
|
||||
m_mpz_manager.set(result, m_one);
|
||||
else {
|
||||
m_mpz_manager.set(result, m_powers(m_bv_util.get_bv_size(n)));
|
||||
m_mpz_manager.dec(result);
|
||||
}
|
||||
}
|
||||
else {
|
||||
m_mpz_manager.machine_div(x, y, result);
|
||||
}
|
||||
if (m_mpz_manager.is_neg(result))
|
||||
m_mpz_manager.add(result, p, result);
|
||||
m_mpz_manager.del(x);
|
||||
m_mpz_manager.del(y);
|
||||
break;
|
||||
}
|
||||
case OP_BUDIV:
|
||||
case OP_BUDIV0:
|
||||
case OP_BUDIV_I: {
|
||||
SASSERT(n_args == 2);
|
||||
mpz x; m_mpz_manager.set(x, m_tracker.get_value(args[0]));
|
||||
mpz y; m_mpz_manager.set(y, m_tracker.get_value(args[1]));
|
||||
|
||||
if (m_mpz_manager.is_zero(y)) {
|
||||
m_mpz_manager.set(result, m_powers(m_bv_util.get_bv_size(n)));
|
||||
m_mpz_manager.dec(result);
|
||||
}
|
||||
else {
|
||||
m_mpz_manager.machine_div(x, y, result);
|
||||
}
|
||||
m_mpz_manager.del(x);
|
||||
m_mpz_manager.del(y);
|
||||
break;
|
||||
}
|
||||
case OP_BSREM:
|
||||
case OP_BSREM0:
|
||||
case OP_BSREM_I: {
|
||||
SASSERT(n_args == 2);
|
||||
mpz x; m_mpz_manager.set(x, m_tracker.get_value(args[0]));
|
||||
mpz y; m_mpz_manager.set(y, m_tracker.get_value(args[1]));
|
||||
unsigned bv_sz = m_bv_util.get_bv_size(args[0]);
|
||||
const mpz & p = m_powers(bv_sz);
|
||||
const mpz & p_half = m_powers(bv_sz-1);
|
||||
if (x >= p_half) { m_mpz_manager.sub(x, p, x); }
|
||||
if (y >= p_half) { m_mpz_manager.sub(y, p, y); }
|
||||
|
||||
if (m_mpz_manager.is_zero(y)) {
|
||||
m_mpz_manager.set(result, x);
|
||||
}
|
||||
else {
|
||||
m_mpz_manager.rem(x, y, result);
|
||||
}
|
||||
if (m_mpz_manager.is_neg(result))
|
||||
m_mpz_manager.add(result, p, result);
|
||||
m_mpz_manager.del(x);
|
||||
m_mpz_manager.del(y);
|
||||
break;
|
||||
}
|
||||
case OP_BUREM:
|
||||
case OP_BUREM0:
|
||||
case OP_BUREM_I: {
|
||||
SASSERT(n_args == 2);
|
||||
mpz x; m_mpz_manager.set(x, m_tracker.get_value(args[0]));
|
||||
mpz y; m_mpz_manager.set(y, m_tracker.get_value(args[1]));
|
||||
|
||||
if (m_mpz_manager.is_zero(y)) {
|
||||
m_mpz_manager.set(result, x);
|
||||
}
|
||||
else {
|
||||
m_mpz_manager.mod(x, y, result);
|
||||
}
|
||||
m_mpz_manager.del(x);
|
||||
m_mpz_manager.del(y);
|
||||
break;
|
||||
}
|
||||
case OP_BSMOD:
|
||||
case OP_BSMOD0:
|
||||
case OP_BSMOD_I:{
|
||||
SASSERT(n_args == 2);
|
||||
mpz x; m_mpz_manager.set(x, m_tracker.get_value(args[0]));
|
||||
mpz y; m_mpz_manager.set(y, m_tracker.get_value(args[1]));
|
||||
unsigned bv_sz = m_bv_util.get_bv_size(args[0]);
|
||||
const mpz & p = m_powers(bv_sz);
|
||||
const mpz & p_half = m_powers(bv_sz-1);
|
||||
if (x >= p_half) { m_mpz_manager.sub(x, p, x); }
|
||||
if (y >= p_half) { m_mpz_manager.sub(y, p, y); }
|
||||
|
||||
if (m_mpz_manager.is_zero(y))
|
||||
m_mpz_manager.set(result, x);
|
||||
else {
|
||||
bool neg_x = m_mpz_manager.is_neg(x);
|
||||
bool neg_y = m_mpz_manager.is_neg(y);
|
||||
mpz abs_x, abs_y;
|
||||
m_mpz_manager.set(abs_x, x);
|
||||
m_mpz_manager.set(abs_y, y);
|
||||
if (neg_x) m_mpz_manager.neg(abs_x);
|
||||
if (neg_y) m_mpz_manager.neg(abs_y);
|
||||
SASSERT(m_mpz_manager.is_nonneg(abs_x) && m_mpz_manager.is_nonneg(abs_y));
|
||||
|
||||
m_mpz_manager.mod(abs_x, abs_y, result);
|
||||
|
||||
if (m_mpz_manager.is_zero(result) || (!neg_x && !neg_y)) {
|
||||
/* Nothing */
|
||||
}
|
||||
else if (neg_x && !neg_y) {
|
||||
m_mpz_manager.neg(result);
|
||||
m_mpz_manager.add(result, y, result);
|
||||
}
|
||||
else if (!neg_x && neg_y) {
|
||||
m_mpz_manager.add(result, y, result);
|
||||
}
|
||||
else {
|
||||
m_mpz_manager.neg(result);
|
||||
}
|
||||
|
||||
m_mpz_manager.del(abs_x);
|
||||
m_mpz_manager.del(abs_y);
|
||||
}
|
||||
|
||||
if (m_mpz_manager.is_neg(result))
|
||||
m_mpz_manager.add(result, p, result);
|
||||
|
||||
m_mpz_manager.del(x);
|
||||
m_mpz_manager.del(y);
|
||||
break;
|
||||
}
|
||||
case OP_BAND: {
|
||||
SASSERT(n_args >= 2);
|
||||
m_mpz_manager.set(result, m_tracker.get_value(args[0]));
|
||||
for (unsigned i = 1; i < n_args; i++)
|
||||
m_mpz_manager.bitwise_and(result, m_tracker.get_value(args[i]), result);
|
||||
break;
|
||||
}
|
||||
case OP_BOR: {
|
||||
SASSERT(n_args >= 2);
|
||||
m_mpz_manager.set(result, m_tracker.get_value(args[0]));
|
||||
for (unsigned i = 1; i < n_args; i++) {
|
||||
m_mpz_manager.bitwise_or(result, m_tracker.get_value(args[i]), result);
|
||||
}
|
||||
break;
|
||||
}
|
||||
case OP_BXOR: {
|
||||
SASSERT(n_args >= 2);
|
||||
m_mpz_manager.set(result, m_tracker.get_value(args[0]));
|
||||
for (unsigned i = 1; i < n_args; i++)
|
||||
m_mpz_manager.bitwise_xor(result, m_tracker.get_value(args[i]), result);
|
||||
break;
|
||||
}
|
||||
case OP_BNAND: {
|
||||
SASSERT(n_args >= 2);
|
||||
mpz temp;
|
||||
unsigned bv_sz = m_bv_util.get_bv_size(n);
|
||||
m_mpz_manager.set(result, m_tracker.get_value(args[0]));
|
||||
for (unsigned i = 1; i < n_args; i++) {
|
||||
m_mpz_manager.bitwise_and(result, m_tracker.get_value(args[i]), temp);
|
||||
m_mpz_manager.bitwise_not(bv_sz, temp, result);
|
||||
}
|
||||
m_mpz_manager.del(temp);
|
||||
break;
|
||||
}
|
||||
case OP_BNOR: {
|
||||
SASSERT(n_args >= 2);
|
||||
mpz temp;
|
||||
unsigned bv_sz = m_bv_util.get_bv_size(n);
|
||||
m_mpz_manager.set(result, m_tracker.get_value(args[0]));
|
||||
for (unsigned i = 1; i < n_args; i++) {
|
||||
m_mpz_manager.bitwise_or(result, m_tracker.get_value(args[i]), temp);
|
||||
m_mpz_manager.bitwise_not(bv_sz, temp, result);
|
||||
}
|
||||
m_mpz_manager.del(temp);
|
||||
break;
|
||||
}
|
||||
case OP_BNOT: {
|
||||
SASSERT(n_args == 1);
|
||||
m_mpz_manager.bitwise_not(m_bv_util.get_bv_size(args[0]), m_tracker.get_value(args[0]), result);
|
||||
break;
|
||||
}
|
||||
case OP_ULT:
|
||||
case OP_ULEQ:
|
||||
case OP_UGT:
|
||||
case OP_UGEQ: {
|
||||
SASSERT(n_args == 2);
|
||||
const mpz & x = m_tracker.get_value(args[0]);
|
||||
const mpz & y = m_tracker.get_value(args[1]);
|
||||
if ((k == OP_ULT && m_mpz_manager.lt(x, y)) ||
|
||||
(k == OP_ULEQ && m_mpz_manager.le(x, y)) ||
|
||||
(k == OP_UGT && m_mpz_manager.gt(x, y)) ||
|
||||
(k == OP_UGEQ && m_mpz_manager.ge(x, y)))
|
||||
m_mpz_manager.set(result, m_one);
|
||||
break;
|
||||
}
|
||||
case OP_SLT:
|
||||
case OP_SLEQ:
|
||||
case OP_SGT:
|
||||
case OP_SGEQ: {
|
||||
SASSERT(n_args == 2);
|
||||
mpz x; m_mpz_manager.set(x, m_tracker.get_value(args[0]));
|
||||
mpz y; m_mpz_manager.set(y, m_tracker.get_value(args[1]));
|
||||
unsigned bv_sz = m_bv_util.get_bv_size(args[0]);
|
||||
const mpz & p = m_powers(bv_sz);
|
||||
const mpz & p_half = m_powers(bv_sz-1);
|
||||
if (x >= p_half) { m_mpz_manager.sub(x, p, x); }
|
||||
if (y >= p_half) { m_mpz_manager.sub(y, p, y); }
|
||||
if ((k == OP_SLT && m_mpz_manager.lt(x, y)) ||
|
||||
(k == OP_SLEQ && m_mpz_manager.le(x, y)) ||
|
||||
(k == OP_SGT && m_mpz_manager.gt(x, y)) ||
|
||||
(k == OP_SGEQ && m_mpz_manager.ge(x, y)))
|
||||
m_mpz_manager.set(result, m_one);
|
||||
m_mpz_manager.del(x);
|
||||
m_mpz_manager.del(y);
|
||||
break;
|
||||
}
|
||||
case OP_BIT2BOOL: {
|
||||
SASSERT(n_args == 1);
|
||||
const mpz & child = m_tracker.get_value(args[0]);
|
||||
m_mpz_manager.set(result, child);
|
||||
break;
|
||||
}
|
||||
case OP_BASHR: {
|
||||
SASSERT(n_args == 2);
|
||||
m_mpz_manager.set(result, m_tracker.get_value(args[0]));
|
||||
mpz first;
|
||||
const mpz & p = m_powers(m_bv_util.get_bv_size(args[0])-1);
|
||||
m_mpz_manager.bitwise_and(result, p, first);
|
||||
mpz shift; m_mpz_manager.set(shift, m_tracker.get_value(args[1]));
|
||||
mpz temp;
|
||||
while (!m_mpz_manager.is_zero(shift)) {
|
||||
m_mpz_manager.machine_div(result, m_two, temp);
|
||||
m_mpz_manager.add(temp, first, result);
|
||||
m_mpz_manager.dec(shift);
|
||||
}
|
||||
m_mpz_manager.del(first);
|
||||
m_mpz_manager.del(shift);
|
||||
m_mpz_manager.del(temp);
|
||||
break;
|
||||
}
|
||||
case OP_BLSHR: {
|
||||
SASSERT(n_args == 2);
|
||||
m_mpz_manager.set(result, m_tracker.get_value(args[0]));
|
||||
mpz shift; m_mpz_manager.set(shift, m_tracker.get_value(args[1]));
|
||||
while (!m_mpz_manager.is_zero(shift)) {
|
||||
m_mpz_manager.machine_div(result, m_two, result);
|
||||
m_mpz_manager.dec(shift);
|
||||
}
|
||||
m_mpz_manager.del(shift);
|
||||
break;
|
||||
}
|
||||
case OP_BSHL: {
|
||||
SASSERT(n_args == 2);
|
||||
m_mpz_manager.set(result, m_tracker.get_value(args[0]));
|
||||
mpz shift; m_mpz_manager.set(shift, m_tracker.get_value(args[1]));
|
||||
while (!m_mpz_manager.is_zero(shift)) {
|
||||
m_mpz_manager.mul(result, m_two, result);
|
||||
m_mpz_manager.dec(shift);
|
||||
}
|
||||
const mpz & p = m_powers(m_bv_util.get_bv_size(n));
|
||||
m_mpz_manager.rem(result, p, result);
|
||||
m_mpz_manager.del(shift);
|
||||
break;
|
||||
}
|
||||
case OP_SIGN_EXT: {
|
||||
SASSERT(n_args == 1);
|
||||
m_mpz_manager.set(result, m_tracker.get_value(args[0]));
|
||||
break;
|
||||
}
|
||||
default:
|
||||
NOT_IMPLEMENTED_YET();
|
||||
}
|
||||
}
|
||||
else {
|
||||
NOT_IMPLEMENTED_YET();
|
||||
}
|
||||
|
||||
TRACE("sls_eval", tout << "(" << fd->get_name();
|
||||
for (unsigned i = 0; i < n_args; i++)
|
||||
tout << " " << m_mpz_manager.to_string(m_tracker.get_value(args[i]));
|
||||
tout << ") ---> " << m_mpz_manager.to_string(result);
|
||||
if (m_manager.is_bool(fd->get_range())) tout << " [Boolean]";
|
||||
else tout << " [vector size: " << m_bv_util.get_bv_size(fd->get_range()) << "]";
|
||||
tout << std::endl; );
|
||||
|
||||
SASSERT(m_mpz_manager.is_nonneg(result));
|
||||
}
|
||||
|
||||
void eval_checked(expr * n, mpz & result) {
|
||||
switch(n->get_kind()) {
|
||||
case AST_APP: {
|
||||
app * a = to_app(n);
|
||||
(*this)(a, result);
|
||||
|
||||
unsigned n_args = a->get_num_args();
|
||||
m_temp_exprs.reset();
|
||||
for (unsigned i = 0; i < n_args; i++) {
|
||||
expr * arg = a->get_arg(i);
|
||||
const mpz & v = m_tracker.get_value(arg);
|
||||
m_temp_exprs.push_back(m_tracker.mpz2value(arg->get_sort(), v));
|
||||
}
|
||||
expr_ref q(m_manager), temp(m_manager);
|
||||
q = m_manager.mk_app(a->get_decl(), m_temp_exprs.size(), m_temp_exprs.data());
|
||||
model dummy_model(m_manager);
|
||||
model_evaluator evaluator(dummy_model);
|
||||
evaluator(q, temp);
|
||||
mpz check_res;
|
||||
m_tracker.value2mpz(temp, check_res);
|
||||
CTRACE("sls", !m_mpz_manager.eq(check_res, result),
|
||||
tout << "EVAL BUG: IS " << m_mpz_manager.to_string(result) <<
|
||||
" SHOULD BE " << m_mpz_manager.to_string(check_res) << std::endl; );
|
||||
SASSERT(m_mpz_manager.eq(check_res, result));
|
||||
m_mpz_manager.del(check_res);
|
||||
|
||||
break;
|
||||
}
|
||||
default:
|
||||
NOT_IMPLEMENTED_YET();
|
||||
}
|
||||
}
|
||||
|
||||
void run_serious_update(unsigned cur_depth) {
|
||||
// precondition: m_traversal_stack contains the entry point(s)
|
||||
expr_fast_mark1 visited;
|
||||
mpz new_value;
|
||||
|
||||
double new_score;
|
||||
|
||||
SASSERT(cur_depth < m_traversal_stack.size());
|
||||
while (cur_depth != static_cast<unsigned>(-1)) {
|
||||
ptr_vector<expr> & cur_depth_exprs = m_traversal_stack[cur_depth];
|
||||
|
||||
for (unsigned i = 0; i < cur_depth_exprs.size(); i++) {
|
||||
expr * cur = cur_depth_exprs[i];
|
||||
|
||||
(*this)(to_app(cur), new_value);
|
||||
m_tracker.set_value(cur, new_value);
|
||||
|
||||
new_score = m_tracker.score(cur);
|
||||
if (m_tracker.is_top_expr(cur))
|
||||
{
|
||||
m_tracker.adapt_top_sum(cur, new_score, m_tracker.get_score(cur));
|
||||
if (m_mpz_manager.eq(new_value,m_one))
|
||||
m_tracker.make_assertion(cur);
|
||||
else
|
||||
m_tracker.break_assertion(cur);
|
||||
}
|
||||
|
||||
m_tracker.set_score(cur, new_score);
|
||||
m_tracker.set_score_prune(cur, new_score);
|
||||
|
||||
if (m_tracker.has_uplinks(cur)) {
|
||||
ptr_vector<expr> & ups = m_tracker.get_uplinks(cur);
|
||||
for (unsigned j = 0; j < ups.size(); j++) {
|
||||
expr * next = ups[j];
|
||||
unsigned next_d = m_tracker.get_distance(next);
|
||||
SASSERT(next_d < cur_depth);
|
||||
if (!visited.is_marked(next)) {
|
||||
m_traversal_stack[next_d].push_back(next);
|
||||
visited.mark(next);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
cur_depth_exprs.reset();
|
||||
cur_depth--;
|
||||
}
|
||||
|
||||
m_mpz_manager.del(new_value);
|
||||
}
|
||||
|
||||
void run_update(unsigned cur_depth) {
|
||||
// precondition: m_traversal_stack contains the entry point(s)
|
||||
expr_fast_mark1 visited;
|
||||
mpz new_value;
|
||||
|
||||
double new_score;
|
||||
|
||||
SASSERT(cur_depth < m_traversal_stack.size());
|
||||
while (cur_depth != static_cast<unsigned>(-1)) {
|
||||
ptr_vector<expr> & cur_depth_exprs = m_traversal_stack[cur_depth];
|
||||
|
||||
for (unsigned i = 0; i < cur_depth_exprs.size(); i++) {
|
||||
expr * cur = cur_depth_exprs[i];
|
||||
|
||||
(*this)(to_app(cur), new_value);
|
||||
m_tracker.set_value(cur, new_value);
|
||||
new_score = m_tracker.score(cur);
|
||||
if (m_tracker.is_top_expr(cur))
|
||||
m_tracker.adapt_top_sum(cur, new_score, m_tracker.get_score(cur));
|
||||
m_tracker.set_score(cur, new_score);
|
||||
if (m_tracker.has_uplinks(cur)) {
|
||||
ptr_vector<expr> & ups = m_tracker.get_uplinks(cur);
|
||||
for (unsigned j = 0; j < ups.size(); j++) {
|
||||
expr * next = ups[j];
|
||||
unsigned next_d = m_tracker.get_distance(next);
|
||||
SASSERT(next_d < cur_depth);
|
||||
if (!visited.is_marked(next)) {
|
||||
m_traversal_stack[next_d].push_back(next);
|
||||
visited.mark(next);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
cur_depth_exprs.reset();
|
||||
cur_depth--;
|
||||
}
|
||||
|
||||
m_mpz_manager.del(new_value);
|
||||
}
|
||||
|
||||
void update_all() {
|
||||
unsigned max_depth = 0;
|
||||
|
||||
sls_tracker::entry_point_type::iterator start = m_tracker.get_entry_points().begin();
|
||||
sls_tracker::entry_point_type::iterator end = m_tracker.get_entry_points().end();
|
||||
for (sls_tracker::entry_point_type::iterator it = start; it != end; it++) {
|
||||
expr * ep = m_tracker.get_entry_point(it->m_key);
|
||||
unsigned cur_depth = m_tracker.get_distance(ep);
|
||||
if (m_traversal_stack.size() <= cur_depth)
|
||||
m_traversal_stack.resize(cur_depth+1);
|
||||
m_traversal_stack[cur_depth].push_back(ep);
|
||||
if (cur_depth > max_depth) max_depth = cur_depth;
|
||||
}
|
||||
run_serious_update(max_depth);
|
||||
}
|
||||
|
||||
void update(func_decl * fd, const mpz & new_value) {
|
||||
m_tracker.set_value(fd, new_value);
|
||||
expr * ep = m_tracker.get_entry_point(fd);
|
||||
unsigned cur_depth = m_tracker.get_distance(ep);
|
||||
if (m_traversal_stack.size() <= cur_depth)
|
||||
m_traversal_stack.resize(cur_depth+1);
|
||||
m_traversal_stack[cur_depth].push_back(ep);
|
||||
|
||||
run_update(cur_depth);
|
||||
}
|
||||
|
||||
void serious_update(func_decl * fd, const mpz & new_value) {
|
||||
m_tracker.set_value(fd, new_value);
|
||||
expr * ep = m_tracker.get_entry_point(fd);
|
||||
unsigned cur_depth = m_tracker.get_distance(ep);
|
||||
if (m_traversal_stack.size() <= cur_depth)
|
||||
m_traversal_stack.resize(cur_depth+1);
|
||||
m_traversal_stack[cur_depth].push_back(ep);
|
||||
|
||||
run_serious_update(cur_depth);
|
||||
}
|
||||
|
||||
unsigned run_update_bool_prune(unsigned cur_depth) {
|
||||
expr_fast_mark1 visited;
|
||||
|
||||
double prune_score, new_score;
|
||||
unsigned pot_benefits = 0;
|
||||
SASSERT(cur_depth < m_traversal_stack_bool.size());
|
||||
|
||||
ptr_vector<expr> & cur_depth_exprs = m_traversal_stack_bool[cur_depth];
|
||||
|
||||
for (unsigned i = 0; i < cur_depth_exprs.size(); i++) {
|
||||
expr * cur = cur_depth_exprs[i];
|
||||
|
||||
new_score = m_tracker.score(cur);
|
||||
if (m_tracker.is_top_expr(cur))
|
||||
m_tracker.adapt_top_sum(cur, new_score, m_tracker.get_score(cur));
|
||||
|
||||
prune_score = m_tracker.get_score_prune(cur);
|
||||
m_tracker.set_score(cur, new_score);
|
||||
|
||||
if ((new_score > prune_score) && (m_tracker.has_pos_occ(cur)))
|
||||
pot_benefits = 1;
|
||||
if ((new_score <= prune_score) && (m_tracker.has_neg_occ(cur)))
|
||||
pot_benefits = 1;
|
||||
|
||||
if (m_tracker.has_uplinks(cur)) {
|
||||
ptr_vector<expr> & ups = m_tracker.get_uplinks(cur);
|
||||
for (unsigned j = 0; j < ups.size(); j++) {
|
||||
expr * next = ups[j];
|
||||
unsigned next_d = m_tracker.get_distance(next);
|
||||
SASSERT(next_d < cur_depth);
|
||||
if (!visited.is_marked(next)) {
|
||||
m_traversal_stack_bool[next_d].push_back(next);
|
||||
visited.mark(next);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
cur_depth_exprs.reset();
|
||||
cur_depth--;
|
||||
|
||||
while (cur_depth != static_cast<unsigned>(-1)) {
|
||||
ptr_vector<expr> & cur_depth_exprs = m_traversal_stack_bool[cur_depth];
|
||||
if (pot_benefits)
|
||||
{
|
||||
unsigned cur_size = cur_depth_exprs.size();
|
||||
for (unsigned i = 0; i < cur_size; i++) {
|
||||
expr * cur = cur_depth_exprs[i];
|
||||
|
||||
new_score = m_tracker.score(cur);
|
||||
if (m_tracker.is_top_expr(cur))
|
||||
m_tracker.adapt_top_sum(cur, new_score, m_tracker.get_score(cur));
|
||||
m_tracker.set_score(cur, new_score);
|
||||
|
||||
if (m_tracker.has_uplinks(cur)) {
|
||||
ptr_vector<expr> & ups = m_tracker.get_uplinks(cur);
|
||||
for (unsigned j = 0; j < ups.size(); j++) {
|
||||
expr * next = ups[j];
|
||||
unsigned next_d = m_tracker.get_distance(next);
|
||||
SASSERT(next_d < cur_depth);
|
||||
if (!visited.is_marked(next)) {
|
||||
m_traversal_stack_bool[next_d].push_back(next);
|
||||
visited.mark(next);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
cur_depth_exprs.reset();
|
||||
cur_depth--;
|
||||
}
|
||||
|
||||
return pot_benefits;
|
||||
}
|
||||
|
||||
void run_update_prune(unsigned max_depth) {
|
||||
// precondition: m_traversal_stack contains the entry point(s)
|
||||
expr_fast_mark1 visited;
|
||||
mpz new_value;
|
||||
|
||||
unsigned cur_depth = max_depth;
|
||||
SASSERT(cur_depth < m_traversal_stack.size());
|
||||
while (cur_depth != static_cast<unsigned>(-1)) {
|
||||
ptr_vector<expr> & cur_depth_exprs = m_traversal_stack[cur_depth];
|
||||
|
||||
for (unsigned i = 0; i < cur_depth_exprs.size(); i++) {
|
||||
expr * cur = cur_depth_exprs[i];
|
||||
|
||||
(*this)(to_app(cur), new_value);
|
||||
m_tracker.set_value(cur, new_value);
|
||||
// Andreas: Should actually always have uplinks ...
|
||||
if (m_tracker.has_uplinks(cur)) {
|
||||
ptr_vector<expr> & ups = m_tracker.get_uplinks(cur);
|
||||
for (unsigned j = 0; j < ups.size(); j++) {
|
||||
expr * next = ups[j];
|
||||
unsigned next_d = m_tracker.get_distance(next);
|
||||
SASSERT(next_d < cur_depth);
|
||||
if (!visited.is_marked(next)) {
|
||||
if (m_manager.is_bool(next))
|
||||
m_traversal_stack_bool[max_depth].push_back(next);
|
||||
else
|
||||
m_traversal_stack[next_d].push_back(next);
|
||||
visited.mark(next);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
cur_depth_exprs.reset();
|
||||
cur_depth--;
|
||||
}
|
||||
|
||||
m_mpz_manager.del(new_value);
|
||||
}
|
||||
|
||||
unsigned update_prune(func_decl * fd, const mpz & new_value) {
|
||||
m_tracker.set_value(fd, new_value);
|
||||
expr * ep = m_tracker.get_entry_point(fd);
|
||||
unsigned cur_depth = m_tracker.get_distance(ep);
|
||||
|
||||
if (m_traversal_stack_bool.size() <= cur_depth)
|
||||
m_traversal_stack_bool.resize(cur_depth+1);
|
||||
if (m_traversal_stack.size() <= cur_depth)
|
||||
m_traversal_stack.resize(cur_depth+1);
|
||||
|
||||
if (m_manager.is_bool(ep))
|
||||
m_traversal_stack_bool[cur_depth].push_back(ep);
|
||||
else
|
||||
{
|
||||
m_traversal_stack[cur_depth].push_back(ep);
|
||||
run_update_prune(cur_depth);
|
||||
}
|
||||
return run_update_bool_prune(cur_depth);
|
||||
}
|
||||
|
||||
void randomize_local(ptr_vector<func_decl> & unsat_constants) {
|
||||
// Randomize _one_ candidate:
|
||||
unsigned r = m_tracker.get_random_uint(16) % unsat_constants.size();
|
||||
func_decl * fd = unsat_constants[r];
|
||||
mpz temp = m_tracker.get_random(fd->get_range());
|
||||
|
||||
serious_update(fd, temp);
|
||||
|
||||
m_mpz_manager.del(temp);
|
||||
|
||||
TRACE("sls", tout << "Randomization candidate: " << unsat_constants[r]->get_name() << std::endl;
|
||||
tout << "Locally randomized model: " << std::endl;
|
||||
m_tracker.show_model(tout); );
|
||||
|
||||
}
|
||||
|
||||
void randomize_local(expr * e) {
|
||||
randomize_local(m_tracker.get_constants(e));
|
||||
}
|
||||
|
||||
void randomize_local(ptr_vector<expr> const & as) {
|
||||
randomize_local(m_tracker.get_unsat_constants(as));
|
||||
}
|
||||
};
|
||||
|
||||
47
src/ast/sls/sls_powers.h
Normal file
47
src/ast/sls/sls_powers.h
Normal file
|
|
@ -0,0 +1,47 @@
|
|||
/*++
|
||||
Copyright (c) 2012 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
sls_powers.h
|
||||
|
||||
Abstract:
|
||||
|
||||
Power-of-2 module for SLS
|
||||
|
||||
Author:
|
||||
|
||||
Christoph (cwinter) 2012-02-29
|
||||
|
||||
Notes:
|
||||
|
||||
--*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "util/mpz.h"
|
||||
|
||||
class powers : public u_map<mpz*> {
|
||||
unsynch_mpz_manager & m;
|
||||
public:
|
||||
powers(unsynch_mpz_manager & m) : m(m) {}
|
||||
~powers() {
|
||||
for (iterator it = begin(); it != end(); it++) {
|
||||
m.del(*it->m_value);
|
||||
dealloc(it->m_value);
|
||||
}
|
||||
}
|
||||
|
||||
const mpz & operator()(unsigned n) {
|
||||
u_map<mpz*>::iterator it = find_iterator(n);
|
||||
if (it != end())
|
||||
return *it->m_value;
|
||||
else {
|
||||
mpz * new_obj = alloc(mpz);
|
||||
m.mul2k(m.mk_z(1), n, *new_obj);
|
||||
insert(n, new_obj);
|
||||
return *new_obj;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
1094
src/ast/sls/sls_tracker.h
Normal file
1094
src/ast/sls/sls_tracker.h
Normal file
File diff suppressed because it is too large
Load diff
|
|
@ -70,8 +70,7 @@ struct well_sorted_proc {
|
|||
strm << "Expected sort: " << mk_pp(expected_sort, m_manager) << '\n';
|
||||
strm << "Actual sort: " << mk_pp(actual_sort, m_manager) << '\n';
|
||||
strm << "Function sort: " << mk_pp(decl, m_manager) << '.';
|
||||
auto str = strm.str();
|
||||
warning_msg("%s", str.c_str());
|
||||
warning_msg("%s", std::move(strm).str().c_str());
|
||||
m_error = true;
|
||||
return;
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue