z3-z3-4.13.0.src.math.lp.nla_order_lemmas.cpp Maven / Gradle / Ivy
The newest version!
/*++
Copyright (c) 2017 Microsoft Corporation
Author:
Nikolaj Bjorner (nbjorner)
Lev Nachmanson (levnach)
--*/
#include "math/lp/nla_order_lemmas.h"
#include "math/lp/nla_core.h"
#include "math/lp/nla_common.h"
#include "math/lp/factorization_factory_imp.h"
namespace nla {
typedef lp::lar_term term;
// The order lemma is
// a > b && c > 0 => ac > bc
void order::order_lemma() {
TRACE("nla_solver", );
if (!c().params().arith_nl_order()) {
TRACE("nla_solver", tout << "not generating order lemmas\n";);
return;
}
const auto& to_ref = c().m_to_refine;
unsigned r = random();
unsigned sz = to_ref.size();
for (unsigned i = 0; i < sz && !done(); ++i) {
lpvar j = to_ref[(i + r) % sz];
order_lemma_on_monic(c().emons()[j]);
}
}
// The order lemma is
// a > b && c > 0 => ac > bc
// Consider here some binary factorizations of m=ac and
// try create order lemmas with either factor playing the role of c.
void order::order_lemma_on_monic(const monic& m) {
TRACE("nla_solver_details",
tout << "m = " << pp_mon(c(), m););
for (auto ac : factorization_factory_imp(m, _())) {
if (ac.size() != 2)
continue;
if (ac.is_mon())
order_lemma_on_binomial(ac.mon());
else
order_lemma_on_factorization(m, ac);
if (done())
break;
}
}
// Here ac is a monic of size 2
// Trying to get an order lemma is
// a > b && c > 0 => ac > bc,
// with either variable of ac playing the role of c
void order::order_lemma_on_binomial(const monic& ac) {
TRACE("nla_solver", tout << pp_mon_with_vars(c(), ac););
SASSERT(!check_monic(ac) && ac.size() == 2);
const rational mult_val = mul_val(ac);
const rational acv = var_val(ac);
bool gt = acv > mult_val;
bool k = false;
do {
order_lemma_on_binomial_sign(ac, ac.vars()[k], ac.vars()[!k], gt? 1: -1);
order_lemma_on_factor_binomial_explore(ac, k);
k = !k;
}
while (k);
}
/**
\brief
sign = the sign of val(xy) - val(x) * val(y) != 0
y <= 0 or x < a or xy >= ay
y <= 0 or x > a or xy <= ay
y >= 0 or x < a or xy <= ay
y >= 0 or x > a or xy >= ay
*/
void order::order_lemma_on_binomial_sign(const monic& xy, lpvar x, lpvar y, int sign) {
if (!c().var_is_int(x) && val(x).is_big())
return;
SASSERT(!_().mon_has_zero(xy.vars()));
int sy = rat_sign(val(y));
new_lemma lemma(c(), __FUNCTION__);
lemma |= ineq(y, sy == 1 ? llc::LE : llc::GE, 0); // negate sy
lemma |= ineq(x, sy*sign == 1 ? llc::GT : llc::LT , val(x));
lemma |= ineq(term(xy.var(), - val(x), y), sign == 1 ? llc::LE : llc::GE, 0);
}
// We look for monics e = m.rvars()[k]*d and see if we can create an order lemma for m and e
void order::order_lemma_on_factor_binomial_explore(const monic& ac, bool k) {
TRACE("nla_solver", tout << "ac = " << pp_mon_with_vars(c(), ac););
SASSERT(ac.size() == 2);
lpvar c = ac.vars()[k];
for (monic const& bd : _().emons().get_products_of(c)) {
if (bd.var() == ac.var())
continue;
TRACE("nla_solver", tout << "bd = " << pp_mon_with_vars(_(), bd););
order_lemma_on_factor_binomial_rm(ac, k, bd);
if (done())
break;
}
}
// ac is a binomial
// create order lemma on monics bd where d is equivalent to ac[k]
void order::order_lemma_on_factor_binomial_rm(const monic& ac, bool k, const monic& bd) {
TRACE("nla_solver",
tout << "ac=" << pp_mon_with_vars(_(), ac) << "\n";
tout << "k=" << k << "\n";
tout << "bd=" << pp_mon_with_vars(_(), bd) << "\n";
);
factor d(_().m_evars.find(ac.vars()[k]).var(), factor_type::VAR);
factor b;
if (c().divide(bd, d, b)) {
order_lemma_on_binomial_ac_bd(ac, k, bd, b, d.var());
}
}
// ac >= bd && |c| = |d| => ac/|c| >= bd/|d|
void order::order_lemma_on_binomial_ac_bd(const monic& ac, bool k, const monic& bd, const factor& b, lpvar d) {
lpvar a = ac.vars()[!k];
lpvar c = ac.vars()[k];
TRACE("nla_solver",
tout << "ac = " << pp_mon(_(), ac) << "a = " << pp_var(_(), a) << "c = " << pp_var(_(), c) << "\nbd = " << pp_mon(_(), bd) << "b = " << pp_fac(_(), b) << "d = " << pp_var(_(), d) << "\n";
);
SASSERT(_().m_evars.find(c).var() == d);
rational acv = var_val(ac);
rational av = val(a);
rational c_sign = rrat_sign(val(c));
rational d_sign = rrat_sign(val(d));
rational bdv = var_val(bd);
rational bv = val(b);
// Notice that ac/|c| = a*c_sign , and bd/|d| = b*d_sign
auto av_c_s = av*c_sign; auto bv_d_s = bv*d_sign;
TRACE("nla_solver",
tout << "acv = " << acv << ", av = " << av << ", c_sign = " << c_sign << ", d_sign = " << d_sign << ", bdv = " << bdv <<
"\nbv = " << bv << ", av_c_s = " << av_c_s << ", bv_d_s = " << bv_d_s << "\n";);
if (acv >= bdv && av_c_s < bv_d_s)
generate_mon_ol(ac, a, c_sign, c, bd, b, d_sign, d, llc::LT);
else if (acv <= bdv && av_c_s > bv_d_s)
generate_mon_ol(ac, a, c_sign, c, bd, b, d_sign, d, llc::GT);
}
// |c_sign| = 1, and c*c_sign > 0
// |d_sign| = 1, and d*d_sign > 0
// c and d are equivalent |c| == |d|
// ac > bd => ac/|c| > bd/|d| => a*c_sign > b*d_sign
// but the last inequality does not hold
void order::generate_mon_ol(const monic& ac,
lpvar a,
const rational& c_sign,
lpvar c,
const monic& bd,
const factor& b,
const rational& d_sign,
lpvar d,
llc ab_cmp) {
SASSERT(ab_cmp == llc::LT || ab_cmp == llc::GT);
SASSERT(ab_cmp != llc::LT || (var_val(ac) >= var_val(bd) && val(a)*c_sign < val(b)*d_sign));
SASSERT(ab_cmp != llc::GT || (var_val(ac) <= var_val(bd) && val(a)*c_sign > val(b)*d_sign));
new_lemma lemma(_(), __FUNCTION__);
lemma |= ineq(term(c_sign, c), llc::LE, 0);
lemma &= c; // this explains c == +- d
lemma |= ineq(term(c_sign, a, -d_sign * b.rat_sign(), b.var()), negate(ab_cmp), 0);
lemma |= ineq(term(ac.var(), rational(-1), var(bd)), ab_cmp, 0);
lemma &= bd;
lemma &= b;
lemma &= d;
}
// a > b && c > 0 => ac > bc
// a >< b && c > 0 => ac >< bc
// a >< b && c < 0 => ac <> bc
// ac[k] plays the role of c
bool order::order_lemma_on_ac_and_bc(const monic& rm_ac,
const factorization& ac_f,
bool k,
const monic& rm_bd) {
TRACE("nla_solver",
tout << "rm_ac = " << pp_mon_with_vars(_(), rm_ac) << "\n";
tout << "rm_bd = " << pp_mon_with_vars(_(), rm_bd) << "\n";
tout << "ac_f[k] = ";
c().print_factor_with_vars(ac_f[k], tout););
factor b;
return
c().divide(rm_bd, ac_f[k], b) &&
order_lemma_on_ac_and_bc_and_factors(rm_ac, ac_f[!k], ac_f[k], rm_bd, b);
}
// Here m = ab, that is ab is binary factorization of m.
// We try to find a monic n = cd, such that |b| = |d|
// and get lemma m R n & |b| = |d| => ab/|b| R cd /|d|, where R is a relation
void order::order_lemma_on_factorization(const monic& m, const factorization& ab) {
bool sign = false;
for (factor f: ab)
sign ^= f.sign();
const rational rsign = sign_to_rat(sign);
const rational fv = val(var(ab[0])) * val(var(ab[1]));
const rational mv = rsign * var_val(m);
TRACE("nla_solver",
tout << "ab.size()=" << ab.size() << "\n";
tout << "we should have mv =" << mv << " = " << fv << " = fv\n";
tout << "m = "; _().print_monic_with_vars(m, tout); tout << "\nab ="; _().print_factorization(ab, tout););
if (mv != fv && !c().has_real(m)) {
bool gt = mv > fv;
for (unsigned j = 0, k = 1; j < 2; j++, k--) {
new_lemma lemma(_(), __FUNCTION__);
order_lemma_on_ab(lemma, m, rsign, var(ab[k]), var(ab[j]), gt);
lemma &= ab;
lemma &= m;
}
}
for (unsigned j = 0, k = 1; j < 2; j++, k--) {
order_lemma_on_ac_explore(m, ab, j == 1);
}
}
void order::order_lemma_on_ac_explore(const monic& rm, const factorization& ac, bool k) {
const factor c = ac[k];
TRACE("nla_solver", tout << "c = "; _().print_factor_with_vars(c, tout); );
if (c.is_var()) {
TRACE("nla_solver", tout << "var(c) = " << var(c););
for (monic const& bc : _().emons().get_use_list(c.var())) {
if (order_lemma_on_ac_and_bc(rm, ac, k, bc))
return;
}
}
else {
for (monic const& bc : _().emons().get_products_of(c.var())) {
if (order_lemma_on_ac_and_bc(rm, ac, k, bc))
return;
}
}
}
void order::generate_ol_eq(const monic& ac,
const factor& a,
const factor& c,
const monic& bc,
const factor& b) {
new_lemma lemma(_(), __FUNCTION__);
IF_VERBOSE(100,
verbose_stream()
<< var_val(ac) << "(" << mul_val(ac) << "): " << ac
<< " " << var_val(bc) << "(" << mul_val(bc) << "): " << bc << "\n"
<< " a " << "*v" << var(a) << " " << val(a) << "\n"
<< " b " << "*v" << var(b) << " " << val(b) << "\n"
<< " c " << "*v" << var(c) << " " << val(c) << "\n");
// ac == bc
lemma |= ineq(c.var(), llc::EQ, 0); // c is not equal to zero
lemma |= ineq(term(ac.var(), -rational(1), bc.var()), llc::NE, 0);
lemma |= ineq(term(a.rat_sign(), a.var(), -b.rat_sign(), b.var()), llc::EQ, 0);
lemma &= ac;
lemma &= a;
lemma &= bc;
lemma &= b;
lemma &= c;
}
void order::generate_ol(const monic& ac,
const factor& a,
const factor& c,
const monic& bc,
const factor& b) {
new_lemma lemma(_(), __FUNCTION__);
TRACE("nla_solver", _().trace_print_ol(ac, a, c, bc, b, tout););
IF_VERBOSE(10, verbose_stream() << var_val(ac) << "(" << mul_val(ac) << "): " << ac
<< " " << var_val(bc) << "(" << mul_val(bc) << "): " << bc << "\n"
<< " a " << "*v" << var(a) << " " << val(a) << "\n"
<< " b " << "*v" << var(b) << " " << val(b) << "\n"
<< " c " << "*v" << var(c) << " " << val(c) << "\n");
// c > 0 and ac >= bc => a >= b
// c > 0 and ac <= bc => a <= b
// c < 0 and ac >= bc => a <= b
// c < 0 and ac <= bc => a >= b
lemma |= ineq(c.var(), val(c.var()).is_neg() ? llc::GE : llc::LE, 0);
lemma |= ineq(term(rational(1), ac.var(), -rational(1), bc.var()), var_val(ac) < var_val(bc) ? llc::GT : llc::LT, 0);
// The value of factor k is val(k) = k.rat_sign()*val(k.var()).
// That is why we need to use the factor signs of a and b in the term,
// but the constraint of the lemma is defined by val(a) and val(b).
lemma |= ineq(term(a.rat_sign(), a.var(), -b.rat_sign(), b.var()), val(a) < val(b) ? llc::GE : llc::LE, 0);
lemma &= ac;
lemma &= a;
lemma &= bc;
lemma &= b;
lemma &= c;
}
// We have ac = a*c and bc = b*c.
// Suppose ac >= bc, then ac/|c| >= bc/|c|
// Notice that ac/|c| = a*rat_sign(val(c)|, and similar fo bc/|c|.
//
bool order::order_lemma_on_ac_and_bc_and_factors(const monic& ac,
const factor& a,
const factor& c,
const monic& bc,
const factor& b) {
SASSERT(!val(c).is_zero());
rational c_sign = rational(nla::rat_sign(val(c)));
auto av_c_s = val(a) * c_sign;
auto bv_c_s = val(b) * c_sign;
if ((var_val(ac) > var_val(bc) && av_c_s < bv_c_s) ||
(var_val(ac) < var_val(bc) && av_c_s > bv_c_s)) {
generate_ol(ac, a, c, bc, b);
return true;
}
else if ((var_val(ac) == var_val(bc)) && (av_c_s != bv_c_s)) {
generate_ol_eq(ac, a, c, bc, b);
return true;
}
return false;
}
/*
given: sign * m = ab
lemma b != val(b) || sign*m <= a*val(b)
*/
void order::order_lemma_on_ab_gt(new_lemma& lemma, const monic& m, const rational& sign, lpvar a, lpvar b) {
SASSERT(sign * var_val(m) > val(a) * val(b));
// negate b == val(b)
lemma |= ineq(b, llc::NE, val(b));
// ab <= val(b)a
lemma |= ineq(term(sign, m.var(), -val(b), a), llc::LE, 0);
}
/*
given: sign * m = ab
lemma b != val(b) || sign*m >= a*val(b)
*/
void order::order_lemma_on_ab_lt(new_lemma& lemma, const monic& m, const rational& sign, lpvar a, lpvar b) {
TRACE("nla_solver", tout << "sign = " << sign << ", m = "; c().print_monic(m, tout) << ", a = "; c().print_var(a, tout) <<
", b = "; c().print_var(b, tout) << "\n";);
SASSERT(sign * var_val(m) < val(a) * val(b));
// negate b == val(b)
lemma |= ineq(b, llc::NE, val(b));
// ab >= val(b)a
lemma |= ineq(term(sign, m.var(), -val(b), a), llc::GE, 0);
}
void order::order_lemma_on_ab(new_lemma& lemma, const monic& m, const rational& sign, lpvar a, lpvar b, bool gt) {
if (gt)
order_lemma_on_ab_gt(lemma, m, sign, a, b);
else
order_lemma_on_ab_lt(lemma, m, sign, a, b);
}
}