mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-04-05 17:14:07 +00:00
Code Activity

improved dio handler

Browse source 
Signed-off-by: Lev Nachmanson <levnach@hotmail.com>
This commit is contained in:
Lev Nachmanson 2025-03-10 07:06:36 -10:00 committed by Lev Nachmanson
parent 30021dd74f
commit 6f7b749ff9
11 changed files with 885 additions and 544 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

653
src/math/lp/bound_analyzer_on_row.h
View file

@ -1,24 +1,24 @@
/*++
Copyright (c) 2017 Microsoft Corporation
Copyright (c) 2017 Microsoft Corporation
Module Name:
Module Name:
<name>
<name>
Abstract:
Abstract:
We have an equality : sum by j of row[j]*x[j] = rs
We try to pin a var by pushing the total by using the variable bounds
on a loop we drive the partial sum down, denoting the variables of this process by _u.
In the same loop trying to pin variables by pushing the partial sum up, denoting the variable related to it by _l
We have an equality : sum by j of row[j]*x[j] = rs
We try to pin a var by pushing the total by using the variable bounds
on a loop we drive the partial sum down, denoting the variables of this process by _u.
In the same loop trying to pin variables by pushing the partial sum up, denoting the variable related to it by _l
Author:
Lev Nachmanson (levnach)
Nikolaj Bjorner (nbjorner)
Revision History:
Author:
Lev Nachmanson (levnach)
Nikolaj Bjorner (nbjorner)
Revision History:
--*/
--*/
#pragma once
#include "util/vector.h"
@ -28,312 +28,343 @@ Revision History:
namespace lp {
template <typename C, typename B> // C plays a role of a container, B - lp_bound_propagator
class bound_analyzer_on_row {
const C& m_row;
B & m_bp;
int m_column_of_u; // index of an unlimited from above monoid
// -1 means that such a value is not found, -2 means that at least two of such monoids were found
int m_column_of_l; // index of an unlimited from below monoid
impq m_rs;
template <typename C, typename B> // C plays a role of a container, B - lp_bound_propagator
class bound_analyzer_on_row {
const C& m_row;
B & m_bp;
int m_column_of_u; // index of an unlimited from above monoid
// -1 means that such a value is not found, -2 means that at least two of such monoids were found
int m_column_of_l; // index of an unlimited from below monoid
impq m_rs;
public :
// constructor
bound_analyzer_on_row(
const C & it,
const numeric_pair<mpq>& rs,
B & bp)
:
m_row(it),
m_bp(bp),
m_column_of_u(-1),
m_column_of_l(-1),
m_rs(rs)
{}
public :
// constructor
bound_analyzer_on_row(
const C & it,
const numeric_pair<mpq>& rs,
B & bp)
:
m_row(it),
m_bp(bp),
m_column_of_u(-1),
m_column_of_l(-1),
m_rs(rs)
{}
static unsigned analyze_row(const C & row,
const numeric_pair<mpq>& rs,
B & bp) {
bound_analyzer_on_row a(row, rs, bp);
return a.analyze();
}
private:
unsigned analyze() {
unsigned num_prop = 0;
for (const auto & c : m_row) {
if ((m_column_of_l == -2) && (m_column_of_u == -2))
return 0;
analyze_bound_on_var_on_coeff(c.var(), c.coeff());
static unsigned analyze_row(const C & row,
const numeric_pair<mpq>& rs,
B & bp) {
bound_analyzer_on_row a(row, rs, bp);
return a.analyze();
}
++num_prop;
if (m_column_of_u >= 0)
limit_monoid_u_from_below();
else if (m_column_of_u == -1)
limit_all_monoids_from_below();
else
--num_prop;
++num_prop;
if (m_column_of_l >= 0)
limit_monoid_l_from_above();
else if (m_column_of_l == -1)
limit_all_monoids_from_above();
else
--num_prop;
return num_prop;
}
private:
bool bound_is_available(unsigned j, bool lower_bound) {
return (lower_bound && m_bp.lower_bound_is_available(j)) ||
(!lower_bound && m_bp.upper_bound_is_available(j));
}
const impq & ub(unsigned j) const {
lp_assert(m_bp.upper_bound_is_available(j));
return m_bp.get_upper_bound(j);
}
const impq & lb(unsigned j) const {
lp_assert(m_bp.lower_bound_is_available(j));
return m_bp.get_lower_bound(j);
}
const mpq & monoid_max_no_mult(bool a_is_pos, unsigned j, bool & strict) const {
if (a_is_pos) {
strict = !is_zero(ub(j).y);
return ub(j).x;
}
strict = !is_zero(lb(j).y);
return lb(j).x;
}
mpq monoid_max(const mpq & a, unsigned j) const {
return a * (is_pos(a) ? ub(j).x : lb(j).x);
}
mpq monoid_max(const mpq & a, unsigned j, bool & strict) const {
if (is_pos(a)) {
strict = !is_zero(ub(j).y);
return a * ub(j).x;
}
strict = !is_zero(lb(j).y);
return a * lb(j).x;
}
const mpq & monoid_min_no_mult(bool a_is_pos, unsigned j, bool & strict) const {
if (!a_is_pos) {
strict = !is_zero(ub(j).y);
return ub(j).x;
}
strict = !is_zero(lb(j).y);
return lb(j).x;
}
mpq monoid_min(const mpq & a, unsigned j, bool& strict) const {
if (is_neg(a)) {
strict = !is_zero(ub(j).y);
return a * ub(j).x;
}
strict = !is_zero(lb(j).y);
return a * lb(j).x;
}
mpq monoid_min(const mpq & a, unsigned j) const {
return a * (is_neg(a) ? ub(j).x : lb(j).x);
}
mpq m_total, m_bound;
void limit_all_monoids_from_above() {
int strict = 0;
m_total.reset();
lp_assert(is_zero(m_total));
for (const auto& p : m_row) {
bool str;
m_total -= monoid_min(p.coeff(), p.var(), str);
if (str)
strict++;
}
for (const auto &p : m_row) {
bool str;
bool a_is_pos = is_pos(p.coeff());
m_bound = m_total;
m_bound /= p.coeff();
m_bound += monoid_min_no_mult(a_is_pos, p.var(), str);
if (a_is_pos) {
limit_j(p.var(), m_bound, true, false, strict - static_cast<int>(str) > 0);
unsigned analyze() {
unsigned num_prop = 0;
for (const auto & c : m_row) {
if ((m_column_of_l == -2) && (m_column_of_u == -2))
return 0;
analyze_bound_on_var_on_coeff(c.var(), c.coeff());
}
else {
limit_j(p.var(), m_bound, false, true, strict - static_cast<int>(str) > 0);
}
}
}
void limit_all_monoids_from_below() {
int strict = 0;
m_total.reset();
lp_assert(is_zero(m_total));
for (const auto &p : m_row) {
bool str;
m_total -= monoid_max(p.coeff(), p.var(), str);
if (str)
strict++;
}
for (const auto& p : m_row) {
bool str;
bool a_is_pos = is_pos(p.coeff());
m_bound = m_total;
m_bound /= p.coeff();
m_bound += monoid_max_no_mult(a_is_pos, p.var(), str);
bool astrict = strict - static_cast<int>(str) > 0;
if (a_is_pos) {
limit_j(p.var(), m_bound, true, true, astrict);
}
else {
limit_j(p.var(), m_bound, false, false, astrict);
}
}
}
void limit_monoid_u_from_below() {
// we are going to limit from below the monoid m_column_of_u,
// every other monoid is impossible to limit from below
mpq u_coeff;
unsigned j;
m_bound = -m_rs.x;
bool strict = false;
for (const auto& p : m_row) {
j = p.var();
if (j == static_cast<unsigned>(m_column_of_u)) {
u_coeff = p.coeff();
continue;
}
bool str;
m_bound -= monoid_max(p.coeff(), j, str);
if (str)
strict = true;
}
m_bound /= u_coeff;
if (u_coeff.is_pos()) {
limit_j(m_column_of_u, m_bound, true, true, strict);
} else {
limit_j(m_column_of_u, m_bound, false, false, strict);
}
}
void limit_monoid_l_from_above() {
// we are going to limit from above the monoid m_column_of_l,
// every other monoid is impossible to limit from above
mpq l_coeff;
unsigned j;
m_bound = -m_rs.x;
bool strict = false;
for (const auto &p : m_row) {
j = p.var();
if (j == static_cast<unsigned>(m_column_of_l)) {
l_coeff = p.coeff();
continue;
}
bool str;
m_bound -= monoid_min(p.coeff(), j, str);
if (str)
strict = true;
}
m_bound /= l_coeff;
if (is_pos(l_coeff)) {
limit_j(m_column_of_l, m_bound, true, false, strict);
} else {
limit_j(m_column_of_l, m_bound, false, true, strict);
}
}
// // it is the coefficient before the bounded column
// void provide_evidence(bool coeff_is_pos) {
// /*
// auto & be = m_ibounds.back();
// bool lower_bound = be.m_lower_bound;
// if (!coeff_is_pos)
// lower_bound = !lower_bound;
// auto it = m_row.clone();
// mpq a; unsigned j;
// while (it->next(a, j)) {
// if (be.m_j == j) continue;
// lp_assert(bound_is_available(j, is_neg(a) ? lower_bound : !lower_bound));
// be.m_vector_of_bound_signatures.emplace_back(a, j, numeric_traits<impq>::
// is_neg(a)? lower_bound: !lower_bound);
// }
// delete it;
// */
// }
void limit_j(unsigned bound_j, const mpq& u, bool coeff_before_j_is_pos, bool is_lower_bound, bool strict)
{
auto* lar = &m_bp.lp();
const auto& row = this->m_row;
auto explain = [row, bound_j, coeff_before_j_is_pos, is_lower_bound, strict, lar]() {
(void) strict;
TRACE("bound_analyzer", tout << "explain_bound_on_var_on_coeff, bound_j = " << bound_j << ", coeff_before_j_is_pos = " << coeff_before_j_is_pos << ", is_lower_bound = " << is_lower_bound << ", strict = " << strict << "\n";);
int bound_sign = (is_lower_bound ? 1 : -1);
int j_sign = (coeff_before_j_is_pos ? 1 : -1) * bound_sign;
u_dependency* ret = nullptr;
for (auto const& r : row) {
unsigned j = r.var();
if (j == bound_j)
continue;
mpq const& a = r.coeff();
int a_sign = is_pos(a) ? 1 : -1;
int sign = j_sign * a_sign;
u_dependency* witness = sign > 0 ? lar->get_column_upper_bound_witness(j) : lar->get_column_lower_bound_witness(j);
ret = lar->join_deps(ret, witness);
}
return ret;
};
m_bp.add_bound(u, bound_j, is_lower_bound, strict, explain);
}
void advance_u(unsigned j) {
m_column_of_u = (m_column_of_u == -1) ? j : -2;
}
void advance_l(unsigned j) {
m_column_of_l = (m_column_of_l == -1) ? j : -2;
}
void analyze_bound_on_var_on_coeff(int j, const mpq &a) {
switch (m_bp.get_column_type(j)) {
case column_type::lower_bound:
if (numeric_traits<mpq>::is_pos(a))
advance_u(j);
else
advance_l(j);
break;
case column_type::upper_bound:
if (numeric_traits<mpq>::is_neg(a))
advance_u(j);
++num_prop;
if (m_column_of_u >= 0)
limit_monoid_u_from_below();
else if (m_column_of_u == -1)
limit_all_monoids_from_below();
else
advance_l(j);
break;
case column_type::free_column:
advance_u(j);
advance_l(j);
break;
default:
break;
}
}
};
--num_prop;
++num_prop;
if (m_column_of_l >= 0)
limit_monoid_l_from_above();
else if (m_column_of_l == -1)
limit_all_monoids_from_above();
else
--num_prop;
return num_prop;
}
bool bound_is_available(unsigned j, bool lower_bound) {
return (lower_bound && m_bp.lower_bound_is_available(j)) ||
(!lower_bound && m_bp.upper_bound_is_available(j));
}
const impq & ub(unsigned j) const {
lp_assert(upper_bound_is_available(j));
return get_upper_bound(j);
}
const impq & lb(unsigned j) const {
lp_assert(lower_bound_is_available(j));
return get_lower_bound(j);
}
const mpq & monoid_max_no_mult(bool a_is_pos, unsigned j, bool & strict) const {
if (a_is_pos) {
strict = !is_zero(ub(j).y);
return ub(j).x;
}
strict = !is_zero(lb(j).y);
return lb(j).x;
}
mpq monoid_max(const mpq & a, unsigned j) const {
return a * (is_pos(a) ? ub(j).x : lb(j).x);
}
mpq monoid_max(const mpq & a, unsigned j, bool & strict) const {
if (is_pos(a)) {
strict = !is_zero(ub(j).y);
return a * ub(j).x;
}
strict = !is_zero(lb(j).y);
return a * lb(j).x;
}
const mpq & monoid_min_no_mult(bool a_is_pos, unsigned j, bool & strict) const {
if (!a_is_pos) {
strict = !is_zero(ub(j).y);
return ub(j).x;
}
strict = !is_zero(lb(j).y);
return lb(j).x;
}
mpq monoid_min(const mpq & a, unsigned j, bool& strict) const {
if (is_neg(a)) {
strict = !is_zero(ub(j).y);
return a * ub(j).x;
}
strict = !is_zero(lb(j).y);
return a * lb(j).x;
}
mpq monoid_min(const mpq & a, unsigned j) const {
return a * (is_neg(a) ? ub(j).x : lb(j).x);
}
mpq m_total, m_bound;
void limit_all_monoids_from_above() {
int strict = 0;
m_total = m_rs.x;
for (const auto& p : m_row) {
bool str;
m_total -= monoid_min(p.coeff(), p.var(), str);
if (str)
strict++;
}
for (const auto &p : m_row) {
bool str;
bool a_is_pos = is_pos(p.coeff());
m_bound = m_total;
m_bound /= p.coeff();
m_bound += monoid_min_no_mult(a_is_pos, p.var(), str);
if (a_is_pos) {
limit_j(p.var(), m_bound, true, false, strict - static_cast<int>(str) > 0);
}
else {
limit_j(p.var(), m_bound, false, true, strict - static_cast<int>(str) > 0);
}
}
}
void limit_all_monoids_from_below() {
int strict = 0;
m_total = m_rs.x;
for (const auto &p : m_row) {
bool str;
m_total -= monoid_max(p.coeff(), p.var(), str);
if (str)
strict++;
}
for (const auto& p : m_row) {
bool str;
bool a_is_pos = is_pos(p.coeff());
m_bound = m_total;
m_bound /= p.coeff();
m_bound += monoid_max_no_mult(a_is_pos, p.var(), str);
bool astrict = strict - static_cast<int>(str) > 0;
if (a_is_pos) {
limit_j(p.var(), m_bound, true, true, astrict);
}
else {
limit_j(p.var(), m_bound, false, false, astrict);
}
}
}
void limit_monoid_u_from_below() {
// we are going to limit from below the monoid m_column_of_u,
// every other monoid is impossible to limit from below
mpq u_coeff;
unsigned j;
m_bound = m_rs.x;
bool strict = false;
for (const auto& p : m_row) {
j = p.var();
if (j == static_cast<unsigned>(m_column_of_u)) {
u_coeff = p.coeff();
continue;
}
bool str;
m_bound -= monoid_max(p.coeff(), j, str);
if (str)
strict = true;
}
m_bound /= u_coeff;
if (u_coeff.is_pos()) {
limit_j(m_column_of_u, m_bound, true, true, strict);
} else {
limit_j(m_column_of_u, m_bound, false, false, strict);
}
}
void limit_monoid_l_from_above() {
// we are going to limit from above the monoid m_column_of_l,
// every other monoid is impossible to limit from above
mpq l_coeff;
unsigned j;
m_bound = m_rs.x;
bool strict = false;
for (const auto &p : m_row) {
j = p.var();
if (j == static_cast<unsigned>(m_column_of_l)) {
l_coeff = p.coeff();
continue;
}
bool str;
m_bound -= monoid_min(p.coeff(), j, str);
if (str)
strict = true;
}
m_bound /= l_coeff;
if (is_pos(l_coeff)) {
limit_j(m_column_of_l, m_bound, true, false, strict);
} else {
limit_j(m_column_of_l, m_bound, false, true, strict);
}
}
// // it is the coefficient before the bounded column
// void provide_evidence(bool coeff_is_pos) {
// /*
// auto & be = m_ibounds.back();
// bool lower_bound = be.m_lower_bound;
// if (!coeff_is_pos)
// lower_bound = !lower_bound;
// auto it = m_row.clone();
// mpq a; unsigned j;
// while (it->next(a, j)) {
// if (be.m_j == j) continue;
// lp_assert(bound_is_available(j, is_neg(a) ? lower_bound : !lower_bound));
// be.m_vector_of_bound_signatures.emplace_back(a, j, numeric_traits<impq>::
// is_neg(a)? lower_bound: !lower_bound);
// }
// delete it;
// */
// }
void limit_j(unsigned bound_j, const mpq& u, bool coeff_before_j_is_pos, bool is_lower_bound, bool strict) {
auto* lar = &m_bp.lp();
const auto& row = this->m_row;
auto explain = [row, bound_j, coeff_before_j_is_pos, is_lower_bound, strict, lar]() {
(void) strict;
TRACE("bound_analyzer", tout << "explain_bound_on_var_on_coeff, bound_j = " << bound_j << ", coeff_before_j_is_pos = " << coeff_before_j_is_pos << ", is_lower_bound = " << is_lower_bound << ", strict = " << strict << "\n";);
int bound_sign = (is_lower_bound ? 1 : -1);
int j_sign = (coeff_before_j_is_pos ? 1 : -1) * bound_sign;
u_dependency* ret = nullptr;
for (auto const& r : row) {
unsigned j = r.var();
if (j == bound_j)
continue;
mpq const& a = r.coeff();
int a_sign = is_pos(a) ? 1 : -1;
int sign = j_sign * a_sign;
u_dependency* witness = sign > 0 ? lar->get_column_upper_bound_witness(j) : lar->get_column_lower_bound_witness(j);
ret = lar->join_deps(ret, witness);
}
return ret;
};
m_bp.add_bound(u, bound_j, is_lower_bound, strict, explain);
}
void advance_u(unsigned j) {
m_column_of_u = (m_column_of_u == -1) ? j : -2;
}
void advance_l(unsigned j) {
m_column_of_l = (m_column_of_l == -1) ? j : -2;
}
void analyze_bound_on_var_on_coeff(int j, const mpq &a) {
switch (get_column_type(j)) {
case column_type::lower_bound:
if (numeric_traits<mpq>::is_pos(a))
advance_u(j);
else
advance_l(j);
break;
case column_type::upper_bound:
if (numeric_traits<mpq>::is_neg(a))
advance_u(j);
else
advance_l(j);
break;
case column_type::free_column:
advance_u(j);
advance_l(j);
break;
default:
break;
}
}
const impq& get_upper_bound(unsigned j) const {
return lp().get_upper_bound(j);
}
const impq& get_lower_bound(unsigned j) const {
return lp().get_lower_bound(j);
}
column_type get_column_type(unsigned j) const {
return (lp().get_column_types())[j];
}
const auto& lp() const { return m_bp.lp(); }
auto& lp() { return m_bp.lp(); }
bool upper_bound_is_available(unsigned j) const {
switch (get_column_type(j)) {
case column_type::fixed:
case column_type::boxed:
case column_type::upper_bound:
return true;
default:
return false;
}
}
bool lower_bound_is_available(unsigned j) const {
switch (get_column_type(j)) {
case column_type::fixed:
case column_type::boxed:
case column_type::lower_bound:
return true;
default:
return false;
}
}
};
}

516
src/math/lp/dioph_eq.cpp
View file

File diff suppressed because it is too large Load diff

2
src/math/lp/int_solver.cpp
View file

@ -188,7 +188,7 @@ namespace lp {
}
bool should_gomory_cut() {
return (!settings().dio_eqs() || settings().dio_enable_gomory_cuts())
return (!all_columns_are_integral() ||(!settings().dio_eqs() || settings().dio_enable_gomory_cuts()))
&& m_number_of_calls % settings().m_int_gomory_cut_period == 0;
}

203
src/math/lp/lar_solver.cpp
View file

@ -2509,6 +2509,24 @@ namespace lp {
// Otherwise the new asserted lower bound is is greater than the existing upper bound.
// dep is the reason for the new bound
void lar_solver::write_bound_lemma_to_file(unsigned j, bool is_low, const std::string & file_name, const std::string& location) const {
std::ofstream file(file_name);
if (!file.is_open()) {
// Handle file open error
std::cerr << "Failed to open file: " << file_name << std::endl;
return;
}
write_bound_lemma(j, is_low, location, file);
file.close();
if (file.fail()) {
std::cerr << "Error occurred while writing to file: " << file_name << std::endl;
} else {
std::cout << "Bound lemma written to " << file_name << std::endl;
}
}
void lar_solver::set_crossed_bounds_column_and_deps(unsigned j, bool lower_bound, u_dependency* dep) {
if (m_crossed_bounds_column != null_lpvar) return; // already set
SASSERT(m_crossed_bounds_deps == nullptr);
@ -2518,7 +2536,7 @@ namespace lp {
u_dependency* bdep = lower_bound? ul.lower_bound_witness() : ul.upper_bound_witness();
SASSERT(bdep != nullptr);
m_crossed_bounds_deps = m_dependencies.mk_join(bdep, dep);
insert_to_columns_with_changed_bounds(j);
TRACE("dio", tout << "crossed_bound_deps:\n"; print_explanation(tout, flatten(m_crossed_bounds_deps)) << "\n";);
}
void lar_solver::collect_more_rows_for_lp_propagation(){
@ -2539,6 +2557,189 @@ namespace lp {
return out;
}
// Helper function to format constants in SMT2 format
std::string format_smt2_constant(const mpq& val) {
if (val.is_neg()) {
// Negative constant - use unary minus operator
return std::string("(- ") + abs(val).to_string() + ")";
} else {
// Positive or zero constant - write directly
return val.to_string();
}
}
void lar_solver::write_bound_lemma(unsigned j, bool is_low, const std::string& location, std::ostream & out) const {
// Get the bound value and dependency
mpq bound_val;
bool is_strict = false;
u_dependency* bound_dep = nullptr;
// Get the appropriate bound info
if (is_low) {
if (!has_lower_bound(j, bound_dep, bound_val, is_strict)) {
out << "; Error: Variable " << j << " has no lower bound\n";
return;
}
} else {
if (!has_upper_bound(j, bound_dep, bound_val, is_strict)) {
out << "; Error: Variable " << j << " has no upper bound\n";
return;
}
}
// Start SMT2 file
out << "(set-info : \"generated at " << location;
out << " for " << (is_low ? "lower" : "upper") << " bound of variable " << j << ",";
out << " bound value: " << bound_val << (is_strict ? (is_low ? " < " : " > ") : (is_low ? " <= " : " >= ")) << "x" << j << "\")\n";
// Collect all variables used in dependencies
std::unordered_set<unsigned> vars_used;
vars_used.insert(j);
bool is_int = column_is_int(j);
// Linearize the dependencies
svector<constraint_index> deps;
m_dependencies.linearize(bound_dep, deps);
// Collect variables from constraints
for (auto ci : deps) {
const auto& c = m_constraints[ci];
for (const auto& p : c.coeffs()) {
vars_used.insert(p.second);
if (!column_is_int(p.second))
is_int = false;
}
}
// Collect variables from terms
std::unordered_set<unsigned> term_variables;
for (unsigned var : vars_used) {
if (column_has_term(var)) {
const lar_term& term = get_term(var);
for (const auto& p : term) {
term_variables.insert(p.j());
if (!column_is_int(p.j()))
is_int = false;
}
}
}
// Add term variables to vars_used
vars_used.insert(term_variables.begin(), term_variables.end());
if (is_int) {
out << "(set-logic QF_LIA)\n\n";
}
// Declare variables
out << "; Variable declarations\n";
for (unsigned var : vars_used) {
out << "(declare-const x" << var << " " << (column_is_int(var) ? "Int" : "Real") << ")\n";
}
out << "\n";
// Define term relationships
out << "; Term definitions\n";
for (unsigned var : vars_used) {
if (column_has_term(var)) {
const lar_term& term = get_term(var);
out << "(assert (= x" << var << " ";
if (term.size() == 0) {
out << "0";
} else {
if (term.size() > 1) out << "(+ ";
bool first = true;
for (const auto& p : term) {
if (first) first = false;
else out << " ";
if (p.coeff().is_one()) {
out << "x" << p.j();
} else {
out << "(* " << format_smt2_constant(p.coeff()) << " x" << p.j() << ")";
}
}
if (term.size() > 1) out << ")";
}
out << "))\n";
}
}
out << "\n";
// Add assertions for the dependencies
out << "; Bound dependencies\n";
for (auto ci : deps) {
const auto& c = m_constraints[ci];
out << "(assert ";
// Handle the constraint type and expression
auto k = c.kind();
// Normal constraint with variables
switch (k) {
case LE: out << "(<= "; break;
case LT: out << "(< "; break;
case GE: out << "(>= "; break;
case GT: out << "(> "; break;
case EQ: out << "(= "; break;
default: out << "(unknown-constraint-type "; break;
}
// Left-hand side (variables)
if (c.coeffs().size() == 1) {
// Single variable
auto p = *c.coeffs().begin();
if (p.first.is_one()) {
out << "x" << p.second << " ";
} else {
out << "(* " << format_smt2_constant(p.first) << " x" << p.second << ") ";
}
} else {
// Multiple variables - create a sum
out << "(+ ";
for (auto const& p : c.coeffs()) {
if (p.first.is_one()) {
out << "x" << p.second << " ";
} else {
out << "(* " << format_smt2_constant(p.first) << " x" << p.second << ") ";
}
}
out << ") ";
}
// Right-hand side (constant)
out << format_smt2_constant(c.rhs());
out << "))\n";
}
out << "\n";
// Now add the assertion that contradicts the bound
out << "; Negation of the derived bound\n";
if (is_low) {
if (is_strict) {
out << "(assert (<= x" << j << " " << format_smt2_constant(bound_val) << "))\n";
} else {
out << "(assert (< x" << j << " " << format_smt2_constant(bound_val) << "))\n";
}
} else {
if (is_strict) {
out << "(assert (>= x" << j << " " << format_smt2_constant(bound_val) << "))\n";
} else {
out << "(assert (> x" << j << " " << format_smt2_constant(bound_val) << "))\n";
}
}
out << "\n";
// Check sat and get model if available
out << "(check-sat)\n";
out << "(exit)\n";
}
} // namespace lp

26
src/math/lp/lar_solver.h
View file

@ -617,11 +617,12 @@ public:
}
inline bool column_has_term(lpvar j) const { return m_columns[j].term() != nullptr; }
std::ostream& print_column_info(unsigned j, std::ostream& out) const {
std::ostream& print_column_info(unsigned j, std::ostream& out, bool print_expl = false) const {
m_mpq_lar_core_solver.m_r_solver.print_column_info(j, out);
if (column_has_term(j))
print_term_as_indices(get_term(j), out) << "\n";
display_column_explanation(out, j);
if (print_expl)
display_column_explanation(out, j);
return out;
}
@ -630,10 +631,18 @@ public:
svector<unsigned> vs1, vs2;
m_dependencies.linearize(ul.lower_bound_witness(), vs1);
m_dependencies.linearize(ul.upper_bound_witness(), vs2);
if (!vs1.empty())
out << "lo: " << vs1;
if (!vs2.empty())
out << "hi: " << vs2;
if (!vs1.empty()) {
out << " lo:\n";
for (unsigned ci : vs1) {
display_constraint(out, ci) << "\n";
}
}
if (!vs2.empty()) {
out << " hi:\n";
for (unsigned ci : vs2) {
display_constraint(out, ci) << "\n";
}
}
if (!vs1.empty() || !vs2.empty())
out << "\n";
return out;
@ -716,6 +725,11 @@ public:
return 0;
return m_usage_in_terms[j];
}
void write_bound_lemma_to_file(unsigned j, bool is_low, const std::string & file_name, const std::string & location) const;
void write_bound_lemma(unsigned j, bool is_low, const std::string & location, std::ostream & out) const;
std::function<void (const indexed_uint_set& columns_with_changed_bound)> m_find_monics_with_changed_bounds_func = nullptr;
friend int_solver;
friend int_branch;

4
src/math/lp/lp_core_solver_base.h
View file

@ -436,7 +436,7 @@ public:
return out;
}
std::ostream& print_column_info(unsigned j, std::ostream & out) const {
std::ostream& print_column_info(unsigned j, std::ostream & out, const std::string& var_prefix = "x") const {
if (j >= m_lower_bounds.size()) {
out << "[" << j << "] is not present\n";
return out;
@ -445,7 +445,7 @@ public:
std::stringstream strm;
strm << m_x[j];
std::string j_val = strm.str();
out << "[" << j << "] " << std::setw(6) << " := " << j_val;
out << var_prefix << j << " = " << std::setw(6) << j_val;
if (m_basis_heading[j] >= 0)
out << " base ";
else

1
src/math/lp/lp_settings.cpp
View file

@ -35,4 +35,5 @@ void lp::lp_settings::updt_params(params_ref const& _p) {
m_dio_eqs = p.arith_lp_dio_eqs();
m_dio_enable_gomory_cuts = p.arith_lp_dio_cuts_enable_gomory();
m_dio_branching_period = p.arith_lp_dio_branching_period();
m_dump_bound_lemmas = p.arith_dump_bound_lemmas();
}

4
src/math/lp/lp_settings.h
View file

@ -259,7 +259,7 @@ private:
bool m_dio_enable_hnf_cuts = true;
unsigned m_dio_branching_period = 100; // do branching rarely
unsigned m_dio_report_branch_with_term_tigthening_period = 10000000; // period of reporting the branch with term tigthening
bool m_dump_bound_lemmas = false;
public:
bool print_external_var_name() const { return m_print_external_var_name; }
bool propagate_eqs() const { return m_propagate_eqs;}
@ -277,6 +277,8 @@ public:
return m_bound_propagation;
}
bool dump_bound_lemmas() { return m_dump_bound_lemmas; }
bool& bound_propagation() { return m_bound_propagation; }
lp_settings() : m_default_resource_limit(*this),

2
src/math/lp/numeric_pair.h
View file

@ -239,6 +239,8 @@ struct numeric_pair {
void neg() { x.neg(); y.neg(); }
std::string to_string() const {
if (y.is_zero())
return T_to_string(x);
return std::string("(") + T_to_string(x) + ", " + T_to_string(y) + ")";
}

17
src/math/lp/static_matrix.h
View file

@ -93,16 +93,9 @@ public:
operator T () const { return m_matrix.get_elem(m_row, m_col); }
};
class ref_row {
const static_matrix & m_matrix;
unsigned m_row;
public:
ref_row(const static_matrix & m, unsigned row): m_matrix(m), m_row(row) {}
T operator[](unsigned col) const { return m_matrix.get_elem(m_row, col); }
};
public:
const auto & operator[](unsigned i) const { return m_rows[i]; }
const T & get_val(const column_cell & c) const {
return m_rows[c.var()][c.offset()].coeff();
}
@ -145,6 +138,11 @@ public:
void add_columns_up_to(unsigned j) { while (j >= column_count()) add_column(); }
void remove_element(std_vector<row_cell<T>> & row, row_cell<T> & elem_to_remove);
void remove_element(unsigned ei, row_cell<T> & elem_to_remove) {
remove_element(m_rows[ei], elem_to_remove);
}
void multiply_column(unsigned column, T const & alpha) {
for (auto & t : m_columns[column]) {
@ -452,7 +450,6 @@ public:
return column_container(j, *this);
}
ref_row operator[](unsigned i) const { return ref_row(*this, i);}
typedef T coefftype;
typedef X argtype;
};

1
src/smt/params/smt_params_helper.pyg
View file

@ -94,6 +94,7 @@ def_module_params(module_name='smt',
('arith.int_eq_branch', BOOL, False, 'branching using derived integer equations'),
('arith.ignore_int', BOOL, False, 'treat integer variables as real'),
('arith.dump_lemmas', BOOL, False, 'dump arithmetic theory lemmas to files'),
('arith.dump_bound_lemmas', BOOL, False, 'dump linear solver bounds to files in smt2 format'),
('arith.greatest_error_pivot', BOOL, False, 'Pivoting strategy'),
('arith.eager_eq_axioms', BOOL, True, 'eager equality axioms'),
('arith.auto_config_simplex', BOOL, False, 'force simplex solver in auto_config'),