mirror of
https://github.com/Z3Prover/z3
synced 2025-04-30 12:25:51 +00:00
adding monomial bounds
Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com>
This commit is contained in:
Nikolaj Bjorner
parent
bdecbe4ed7
commit
4e51633e6f
6 changed files with 136 additions and 117 deletions
|
|
@ -13,7 +13,9 @@
|
|||
|
||||
namespace nla {
|
||||
|
||||
monomial_bounds::monomial_bounds(core* c):common(c) {}
|
||||
monomial_bounds::monomial_bounds(core* c):
|
||||
common(c),
|
||||
dep(c->m_intervals.get_dep_intervals()) {}
|
||||
|
||||
bool monomial_bounds::operator()() {
|
||||
bool propagated = false;
|
||||
|
|
@ -29,9 +31,7 @@ namespace nla {
|
|||
* Accumulate product of variables in monomial starting at position 'start'
|
||||
*/
|
||||
void monomial_bounds::compute_product(unsigned start, monic const& m, scoped_dep_interval& product) {
|
||||
auto & intervals = c().m_intervals;
|
||||
auto & dep_intervals = intervals.get_dep_intervals();
|
||||
scoped_dep_interval vi(dep_intervals);
|
||||
scoped_dep_interval vi(dep);
|
||||
for (unsigned i = start; i < m.size(); ) {
|
||||
lpvar v = m.vars()[i];
|
||||
unsigned power = 1;
|
||||
|
|
@ -40,8 +40,8 @@ namespace nla {
|
|||
for (; i < m.size() && m.vars()[i] == v; ++i) {
|
||||
++power;
|
||||
}
|
||||
dep_intervals.power<dep_intervals::with_deps>(vi, power, vi);
|
||||
dep_intervals.mul<dep_intervals::with_deps>(product, vi, product);
|
||||
dep.power<dep_intervals::with_deps>(vi, power, vi);
|
||||
dep.mul<dep_intervals::with_deps>(product, vi, product);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -51,26 +51,27 @@ namespace nla {
|
|||
* a bounds axiom.
|
||||
*/
|
||||
bool monomial_bounds::propagate_value(dep_interval& range, lpvar v) {
|
||||
auto & intervals = c().m_intervals;
|
||||
auto & dep_intervals = intervals.get_dep_intervals();
|
||||
if (dep_intervals.is_below(range, c().val(v))) {
|
||||
auto val = c().val(v);
|
||||
if (dep.is_below(range, val)) {
|
||||
lp::explanation ex;
|
||||
dep_intervals.get_upper_dep(range, ex);
|
||||
auto const& upper = dep_intervals.upper(range);
|
||||
auto cmp = dep_intervals.upper_is_open(range) ? llc::LT : llc::LE;
|
||||
dep.get_upper_dep(range, ex);
|
||||
auto const& upper = dep.upper(range);
|
||||
auto cmp = dep.upper_is_open(range) ? llc::LT : llc::LE;
|
||||
new_lemma lemma(c(), "propagate value - upper bound of range is below value");
|
||||
lemma &= ex;
|
||||
lemma |= ineq(v, cmp, upper);
|
||||
TRACE("nla_solver", dep.display(tout << val << " > ", range) << "\n" << lemma << "\n";);
|
||||
return true;
|
||||
}
|
||||
else if (dep_intervals.is_above(range, c().val(v))) {
|
||||
else if (dep.is_above(range, val)) {
|
||||
lp::explanation ex;
|
||||
dep_intervals.get_lower_dep(range, ex);
|
||||
auto const& lower = dep_intervals.lower(range);
|
||||
auto cmp = dep_intervals.lower_is_open(range) ? llc::GT : llc::GE;
|
||||
dep.get_lower_dep(range, ex);
|
||||
auto const& lower = dep.lower(range);
|
||||
auto cmp = dep.lower_is_open(range) ? llc::GT : llc::GE;
|
||||
new_lemma lemma(c(), "propagate value - lower bound of range is above value");
|
||||
lemma &= ex;
|
||||
lemma |= ineq(v, cmp, lower);
|
||||
TRACE("nla_solver", dep.display(tout << val << " < ", range) << "\n" << lemma << "\n";);
|
||||
return true;
|
||||
}
|
||||
else {
|
||||
|
|
@ -79,26 +80,26 @@ namespace nla {
|
|||
}
|
||||
|
||||
void monomial_bounds::var2interval(lpvar v, scoped_dep_interval& i) {
|
||||
auto & intervals = c().m_intervals;
|
||||
auto & dep_intervals = intervals.get_dep_intervals();
|
||||
lp::constraint_index ci;
|
||||
rational bound;
|
||||
bool is_strict;
|
||||
if (c().has_lower_bound(v, ci, bound, is_strict)) {
|
||||
dep_intervals.set_lower_is_open(i, is_strict);
|
||||
dep_intervals.set_lower(i, bound);
|
||||
dep_intervals.set_lower_dep(i, dep_intervals.mk_leaf(ci));
|
||||
dep.set_lower_is_open(i, is_strict);
|
||||
dep.set_lower(i, bound);
|
||||
dep.set_lower_dep(i, dep.mk_leaf(ci));
|
||||
dep.set_lower_is_inf(i, false);
|
||||
}
|
||||
else {
|
||||
dep_intervals.set_lower_is_inf(i, true);
|
||||
dep.set_lower_is_inf(i, true);
|
||||
}
|
||||
if (c().has_upper_bound(v, ci, bound, is_strict)) {
|
||||
dep_intervals.set_upper_is_open(i, is_strict);
|
||||
dep_intervals.set_upper(i, bound);
|
||||
dep_intervals.set_upper_dep(i, dep_intervals.mk_leaf(ci));
|
||||
dep.set_upper_is_open(i, is_strict);
|
||||
dep.set_upper(i, bound);
|
||||
dep.set_upper_dep(i, dep.mk_leaf(ci));
|
||||
dep.set_upper_is_inf(i, false);
|
||||
}
|
||||
else {
|
||||
dep_intervals.set_upper_is_inf(i, true);
|
||||
dep.set_upper_is_inf(i, true);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -110,15 +111,22 @@ namespace nla {
|
|||
* If the value of m.var() is outside of product_of_all_vars, add a bounds lemma.
|
||||
*/
|
||||
bool monomial_bounds::propagate(monic const& m) {
|
||||
auto & intervals = c().m_intervals;
|
||||
auto & dep_intervals = intervals.get_dep_intervals();
|
||||
scoped_dep_interval product(dep_intervals);
|
||||
scoped_dep_interval vi(dep_intervals), mi(dep_intervals);
|
||||
scoped_dep_interval other_product(dep_intervals);
|
||||
var2interval(m.var(), mi);
|
||||
if (dep_intervals.lower_is_inf(mi) && dep_intervals.upper_is_inf(mi))
|
||||
unsigned num_free, power;
|
||||
lpvar free_var;
|
||||
analyze_monomial(m, num_free, free_var, power);
|
||||
bool m_is_free = is_free(m.var());
|
||||
if (num_free >= 2)
|
||||
return false;
|
||||
dep_intervals.set_value(product, rational::one());
|
||||
if (num_free >= 1 && m_is_free)
|
||||
return false;
|
||||
SASSERT(num_free == 0 || !m_is_free);
|
||||
bool do_propagate_up = num_free == 0;
|
||||
bool do_propagate_down = !m_is_free;
|
||||
scoped_dep_interval product(dep);
|
||||
scoped_dep_interval vi(dep), mi(dep);
|
||||
scoped_dep_interval other_product(dep);
|
||||
var2interval(m.var(), mi);
|
||||
dep.set_value(product, rational::one());
|
||||
for (unsigned i = 0; i < m.size(); ) {
|
||||
lpvar v = m.vars()[i];
|
||||
++i;
|
||||
|
|
@ -126,28 +134,60 @@ namespace nla {
|
|||
for (; i < m.size() && v == m.vars()[i]; ++i)
|
||||
++power;
|
||||
var2interval(v, vi);
|
||||
dep_intervals.power<dep_intervals::with_deps>(vi, power, vi);
|
||||
if (power == 1) {
|
||||
dep_intervals.set<dep_intervals::with_deps>(other_product, product);
|
||||
dep.power<dep_intervals::with_deps>(vi, power, vi);
|
||||
|
||||
if (power == 1 && do_propagate_down && (num_free == 0 || free_var == v)) {
|
||||
dep.set<dep_intervals::with_deps>(other_product, product);
|
||||
compute_product(i, m, other_product);
|
||||
if (propagate_down(m, mi, v, other_product))
|
||||
return true;
|
||||
}
|
||||
dep_intervals.mul<dep_intervals::with_deps>(product, vi, product);
|
||||
dep.mul<dep_intervals::with_deps>(product, vi, product);
|
||||
}
|
||||
return propagate_value(product, m.var());
|
||||
return do_propagate_up && propagate_value(product, m.var());
|
||||
}
|
||||
|
||||
bool monomial_bounds::propagate_down(monic const& m, dep_interval& mi, lpvar v, dep_interval& product) {
|
||||
auto & intervals = c().m_intervals;
|
||||
auto & dep_intervals = intervals.get_dep_intervals();
|
||||
if (!dep_intervals.separated_from_zero(product))
|
||||
if (!dep.separated_from_zero(product))
|
||||
return false;
|
||||
scoped_dep_interval range(dep_intervals);
|
||||
dep_intervals.set<dep_intervals::with_deps>(range, mi);
|
||||
dep_intervals.div<dep_intervals::with_deps>(range, product, range);
|
||||
scoped_dep_interval range(dep);
|
||||
dep.div<dep_intervals::with_deps>(mi, product, range);
|
||||
return propagate_value(range, v);
|
||||
}
|
||||
|
||||
bool monomial_bounds::is_free(lpvar v) const {
|
||||
return !c().has_lower_bound(v) && !c().has_upper_bound(v);
|
||||
}
|
||||
|
||||
bool monomial_bounds::is_zero(lpvar v) const {
|
||||
return
|
||||
c().has_lower_bound(v) &&
|
||||
c().has_upper_bound(v) &&
|
||||
c().get_lower_bound(v).is_zero() &&
|
||||
c().get_lower_bound(v) == c().get_upper_bound(v);
|
||||
}
|
||||
|
||||
void monomial_bounds::analyze_monomial(monic const& m, unsigned& num_free, lpvar& fv, unsigned& fv_power) const {
|
||||
unsigned power = 0;
|
||||
num_free = 0;
|
||||
fv = null_lpvar;
|
||||
fv_power = 0;
|
||||
for (unsigned i = 0; i < m.vars().size(); ) {
|
||||
lpvar v = m.vars()[i];
|
||||
unsigned power = 1;
|
||||
++i;
|
||||
for (; i < m.vars().size() && m.vars()[i] == v; ++i, ++power);
|
||||
if (is_zero(v)) {
|
||||
num_free = 0;
|
||||
return;
|
||||
}
|
||||
if (power % 2 == 1 && is_free(v)) {
|
||||
++num_free;
|
||||
fv_power = power;
|
||||
fv = v;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue