mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-04-28 19:35:50 +00:00
Code Activity

code reviewing order lemmas (#93)

Browse source 
* code reviewing order lemmas

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

* code review monotonity

Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com>
This commit is contained in:
Nikolaj Bjorner 2019-04-20 12:28:28 -07:00 • committed by Lev Nachmanson
parent 1ab3957eea
commit ed3bfcdea9
7 changed files with 233 additions and 204 deletions
Download patch file Download diff file Expand all files Collapse all files

65
src/util/lp/nla_monotone_lemmas.cpp
View file

@ -23,8 +23,19 @@
namespace nla {
monotone::monotone(core * c) : common(c) {}
void monotone::print_monotone_array(const vector<std::pair<std::vector<rational>, unsigned>>& lex_sorted,
std::ostream& out) const {
void monotone::monotonicity_lemma() {
unsigned shift = random();
unsigned size = c().m_to_refine.size();
for(unsigned i = 0; i < size && !done(); i++) {
lpvar v = c().m_to_refine[(i + shift) % size];
monotonicity_lemma(c().m_emons[v]);
}
}
void monotone::print_monotone_array(const monotone_array_t& lex_sorted,
std::ostream& out) const {
out << "Monotone array :\n";
for (const auto & t : lex_sorted ){
out << "(";
@ -33,7 +44,8 @@ void monotone::print_monotone_array(const vector<std::pair<std::vector<rational>
}
out << "}";
}
bool monotone::monotonicity_lemma_on_lex_sorted_rm_upper(const vector<std::pair<std::vector<rational>, unsigned>>& lex_sorted, unsigned i, const smon& rm) {
bool monotone::monotonicity_lemma_on_lex_sorted_rm_upper(const monotone_array_t& lex_sorted, unsigned i, const smon& rm) {
const rational v = abs(vvr(rm));
const auto& key = lex_sorted[i].first;
TRACE("nla_solver", tout << "rm = " << rm << "i = " << i << std::endl;);
@ -49,11 +61,10 @@ bool monotone::monotonicity_lemma_on_lex_sorted_rm_upper(const vector<std::pair<
if (static_cast<int>(strict) != -1 && !has_zero(key)) {
generate_monl_strict(rm, rmk, strict);
return true;
} else {
if (vk < v) {
generate_monl(rm, rmk);
return true;
}
}
else if (vk < v) {
generate_monl(rm, rmk);
return true;
}
}
@ -61,7 +72,7 @@ bool monotone::monotonicity_lemma_on_lex_sorted_rm_upper(const vector<std::pair<
return false;
}
bool monotone::monotonicity_lemma_on_lex_sorted_rm_lower(const vector<std::pair<std::vector<rational>, unsigned>>& lex_sorted, unsigned i, const smon& rm) {
bool monotone::monotonicity_lemma_on_lex_sorted_rm_lower(const monotone_array_t& lex_sorted, unsigned i, const smon& rm) {
const rational v = abs(vvr(rm));
const auto& key = lex_sorted[i].first;
TRACE("nla_solver", tout << "rm = " << rm << "i = " << i << std::endl;);
@ -92,11 +103,11 @@ bool monotone::monotonicity_lemma_on_lex_sorted_rm_lower(const vector<std::pair<
return false;
}
bool monotone::monotonicity_lemma_on_lex_sorted_rm(const vector<std::pair<std::vector<rational>, unsigned>>& lex_sorted, unsigned i, const smon& rm) {
bool monotone::monotonicity_lemma_on_lex_sorted_rm(const monotone_array_t& lex_sorted, unsigned i, const smon& rm) {
return monotonicity_lemma_on_lex_sorted_rm_upper(lex_sorted, i, rm)
|| monotonicity_lemma_on_lex_sorted_rm_lower(lex_sorted, i, rm);
}
bool monotone::monotonicity_lemma_on_lex_sorted(const vector<std::pair<std::vector<rational>, unsigned>>& lex_sorted) {
bool monotone::monotonicity_lemma_on_lex_sorted(const monotone_array_t& lex_sorted) {
for (unsigned i = 0; i < lex_sorted.size(); i++) {
unsigned rmi = lex_sorted[i].second;
const smon& rm = c().m_emons.canonical[rmi];
@ -121,6 +132,7 @@ vector<std::pair<rational, lpvar>> monotone::get_sorted_key_with_vars(const smon
});
return r;
}
void monotone::negate_abs_a_le_abs_b(lpvar a, lpvar b, bool strict) {
rational av = vvr(a);
rational as = rational(nla::rat_sign(av));
@ -138,8 +150,8 @@ void monotone::negate_abs_a_le_abs_b(lpvar a, lpvar b, bool strict) {
// strict version
void monotone::generate_monl_strict(const smon& a,
const smon& b,
unsigned strict) {
const smon& b,
unsigned strict) {
add_empty_lemma();
auto akey = get_sorted_key_with_vars(a);
auto bkey = get_sorted_key_with_vars(b);
@ -189,7 +201,7 @@ void monotone::negate_abs_a_lt_abs_b(lpvar a, lpvar b) {
// not a strict version
void monotone::generate_monl(const smon& a,
const smon& b) {
const smon& b) {
TRACE("nla_solver",
tout << "a = " << a << "\n:";
tout << "b = " << b << "\n:";);
@ -216,7 +228,7 @@ std::vector<rational> monotone::get_sorted_key(const smon& rm) const {
}
bool monotone::monotonicity_lemma_on_rms_of_same_arity(const unsigned_vector& rms) {
vector<std::pair<std::vector<rational>, unsigned>> lex_sorted;
monotone_array_t lex_sorted;
for (unsigned i : rms) {
lex_sorted.push_back(std::make_pair(get_sorted_key(c().m_emons.canonical[i]), i));
}
@ -228,28 +240,6 @@ bool monotone::monotonicity_lemma_on_rms_of_same_arity(const unsigned_vector& rm
TRACE("nla_solver", print_monotone_array(lex_sorted, tout););
return monotonicity_lemma_on_lex_sorted(lex_sorted);
}
void monotone::monotonicity_lemma() {
unsigned shift = random();
unsigned size = c().m_to_refine.size();
for(unsigned i = 0; i < size && !done(); i++) {
lpvar v = c().m_to_refine[(i + shift) % size];
monotonicity_lemma(c().m_emons[v]);
}
}
#if 0
void monotone::monotonicity_lemma() {
auto const& vars = m_rm_table.m_to_refine
unsigned sz = vars.size();
unsigned start = random();
for (unsigned j = 0; !done() && j < sz; ++j) {
unsigned i = (start + j) % sz;
monotonicity_lemma(*m_emons.var2monomial(vars[i]));
}
}
#endif
void monotone::monotonicity_lemma(monomial const& m) {
SASSERT(!check_monomial(m));
@ -262,6 +252,7 @@ void monotone::monotonicity_lemma(monomial const& m) {
else if (m_val > prod_val)
monotonicity_lemma_gt(m, prod_val);
}
void monotone::monotonicity_lemma_gt(const monomial& m, const rational& prod_val) {
add_empty_lemma();
for (lpvar j : m) {