void prune(box & b, contractor & ctc, SMTConfig & config, unordered_set<shared_ptr<constraint>> & used_constraints) {
try {
ctc.prune(b, config);
auto this_used_constraints = ctc.used_constraints();
used_constraints.insert(this_used_constraints.begin(), this_used_constraints.end());
if (config.nra_use_stat) { config.nra_stat.increase_prune(); }
} catch (contractor_exception & e) {
// Do nothing
}
}
// Prune a given box b using ctc, but keep the old state of ctc
void test_prune(box & b, contractor & ctc, SMTConfig & config) {
try {
auto const old_output = ctc.output();
auto const old_used_constraints = ctc.used_constraints();
ctc.prune(b, config);
ctc.set_output(old_output);
ctc.set_used_constraints(old_used_constraints);
} catch (contractor_exception & e) {
// Do nothing
}
}
box ncbt_icp::solve(box b, contractor & ctc, SMTConfig & config) {
thread_local static unordered_set<shared_ptr<constraint>> used_constraints;
used_constraints.clear();
static unsigned prune_count = 0;
thread_local static vector<box> box_stack;
box_stack.clear();
box_stack.push_back(b);
do {
// Loop Invariant
DREAL_LOG_INFO << "ncbt_icp::solve - loop"
<< "\t" << "box stack Size = " << box_stack.size();
b = box_stack.back();
try {
ctc.prune(b, config);
auto const this_used_constraints = ctc.used_constraints();
used_constraints.insert(this_used_constraints.begin(), this_used_constraints.end());
if (config.nra_use_stat) { config.nra_stat.increase_prune(); }
} catch (contractor_exception & e) {
// Do nothing
}
prune_count++;
box_stack.pop_back();
if (!b.is_empty()) {
// SAT
tuple<int, box, box> splits = b.bisect(config.nra_precision);
if (config.nra_use_stat) { config.nra_stat.increase_branch(); }
int const index = get<0>(splits);
if (index >= 0) {
box const & first = get<1>(splits);
box const & second = get<2>(splits);
assert(first.get_idx_last_branched() == index);
assert(second.get_idx_last_branched() == index);
if (second.is_bisectable()) {
box_stack.push_back(second);
box_stack.push_back(first);
} else {
box_stack.push_back(first);
box_stack.push_back(second);
}
} else {
break;
}
} else {
// UNSAT (b is emptified by pruning operators)
// If this bisect_var is not used in all used
// constraints, this box is safe to be popped.
thread_local static unordered_set<Enode *> used_vars;
used_vars.clear();
for (auto used_ctr : used_constraints) {
auto this_used_vars = used_ctr->get_vars();
used_vars.insert(this_used_vars.begin(), this_used_vars.end());
}
while (box_stack.size() > 0) {
int const bisect_var = box_stack.back().get_idx_last_branched();
assert(bisect_var >= 0);
// If this bisect_var is not used in all used
// constraints, this box is safe to be popped.
if (used_vars.find(b.get_vars()[bisect_var]) != used_vars.end()) {
// DREAL_LOG_FATAL << b.get_vars()[bisect_var] << " is used in "
// << *used_ctr << " and it's not safe to skip";
break;
}
// DREAL_LOG_FATAL << b.get_vars()[bisect_var] << " is not used and it's safe to skip this box"
// << " (" << box_stack.size() << ")";
box_stack.pop_back();
}
}
} while (box_stack.size() > 0);
DREAL_LOG_DEBUG << "prune count = " << prune_count;
ctc.set_used_constraints(used_constraints);
return b;
}
box naive_icp::solve(box b, contractor & ctc, SMTConfig & config) {
thread_local static std::unordered_set<std::shared_ptr<constraint>> used_constraints;
used_constraints.clear();
thread_local static vector<box> solns;
thread_local static vector<box> box_stack;
solns.clear();
box_stack.clear();
box_stack.push_back(b);
do {
DREAL_LOG_INFO << "naive_icp::solve - loop"
<< "\t" << "box stack Size = " << box_stack.size();
b = box_stack.back();
box_stack.pop_back();
try {
ctc.prune(b, config);
auto this_used_constraints = ctc.used_constraints();
used_constraints.insert(this_used_constraints.begin(), this_used_constraints.end());
if (config.nra_use_stat) { config.nra_stat.increase_prune(); }
} catch (contractor_exception & e) {
// Do nothing
}
if (!b.is_empty()) {
tuple<int, box, box> splits = b.bisect(config.nra_precision);
if (config.nra_use_stat) { config.nra_stat.increase_branch(); }
int const i = get<0>(splits);
if (i >= 0) {
box const & first = get<1>(splits);
box const & second = get<2>(splits);
assert(first.get_idx_last_branched() == i);
assert(second.get_idx_last_branched() == i);
if (second.is_bisectable()) {
box_stack.push_back(second);
box_stack.push_back(first);
} else {
box_stack.push_back(first);
box_stack.push_back(second);
}
if (config.nra_proof) {
config.nra_proof_out << "[branched on "
<< b.get_name(i)
<< "]" << endl;
}
} else {
config.nra_found_soln++;
if (config.nra_multiple_soln > 1) {
// If --multiple_soln is used
output_solution(b, config, config.nra_found_soln);
}
if (config.nra_found_soln >= config.nra_multiple_soln) {
break;
}
solns.push_back(b);
}
}
} while (box_stack.size() > 0);
ctc.set_used_constraints(used_constraints);
if (config.nra_multiple_soln > 1 && solns.size() > 0) {
return solns.back();
} else {
assert(!b.is_empty() || box_stack.size() == 0);
return b;
}
}