contractor make_contractor(Enode * e,
lbool const
polarity,
box const & b,
unordered_set<Enode *> const & var_set) {
if (e->isNot()) {
return make_contractor(e->get1st(), !polarity, b, var_set);
}
if (e->isOr()) {
// TODO(soonhok): arbitrary number of args
assert(e->getArity() == 2);
contractor c1 = make_contractor(e->get1st(), polarity, b, var_set);
contractor c2 = make_contractor(e->get2nd(), polarity, b, var_set);
return mk_contractor_join(c1, c2);
}
if (e->isAnd()) {
vector<contractor> ctcs;
e = e->getCdr();
while (!e->isEnil()) {
ctcs.push_back(make_contractor(e->getCar(), polarity, b, var_set));
e = e->getCdr();
}
return mk_contractor_seq(ctcs);
} else {
return mk_contractor_ibex_fwdbwd(make_shared<nonlinear_constraint>(e, var_set, polarity));
}
}
void contractor_generic_forall::handle_disjunction(contractor_status & cs, vector<Enode *> const &vec, bool const p) {
DREAL_LOG_DEBUG << "contractor_generic_forall::handle_disjunction" << endl;
unordered_set<Enode *> forall_vars;
for (Enode * e : vec) {
std::unordered_set<Enode *> const & vars = e->get_forall_vars();
forall_vars.insert(vars.begin(), vars.end());
}
unordered_map<Enode*, ibex::Interval> subst;
if (!forall_vars.empty()) {
// Step 2. Find a counter-example
// Solve(¬ l_1 ∧ ¬ l_2 ∧ ... ∧ ¬ l_n)
//
// Make each ¬ l_i as a contractor ctc_i
// Make a fixed_point contractor with ctc_is.
// Pass it to icp::solve
box counterexample = find_CE(cs.m_box, forall_vars, vec, p, cs.m_config);
if (counterexample.is_empty()) {
// Step 2.1. (NO Counterexample)
// Return B.
DREAL_LOG_DEBUG << "handle_disjunction: no counterexample found." << endl
<< "current box = " << endl
<< cs.m_box << endl;
return;
} else {
// Step 2.2. (There IS a counterexample C)
//
// Using C, prune B.
//
// We've found a counterexample (c1, c2) where ¬ f(c1, c2) holds
// Prune X using a point 'y = c2'. (technically, a point in c2, which is an interval)
subst = make_subst_from_value(counterexample, forall_vars);
}
}
// Step 3. Compute B_i = prune(B, l_i)
// Update B with ∨ B_i
// i
thread_local static vector<box> boxes;
boxes.clear();
auto vars = cs.m_box.get_vars();
unordered_set<Enode*> const var_set(vars.begin(), vars.end());
for (Enode * e : vec) {
if (!e->get_exist_vars().empty()) {
lbool polarity = p ? l_True : l_False;
if (e->isNot()) {
polarity = !polarity;
e = e->get1st();
}
auto ctr = make_shared<nonlinear_constraint>(e, var_set, polarity, subst);
if (ctr->get_var_array().size() == 0) {
auto result = ctr->eval(cs.m_box);
if (result.first != false) {
boxes.emplace_back(cs.m_box);
}
} else {
contractor ctc = mk_contractor_ibex_fwdbwd(ctr);
contractor_status bt(cs.m_box, cs.m_config);
ctc.prune(bt);
cs.m_output.union_with(bt.m_output);
unordered_set<shared_ptr<constraint>> const & used_ctrs = bt.m_used_constraints;
cs.m_used_constraints.insert(used_ctrs.begin(), used_ctrs.end());
boxes.emplace_back(bt.m_box);
}
}
}
if (boxes.size() > 0) {
cs.m_box = hull(boxes);
} else {
cs.m_box.set_empty();
}
return;
}
contractor default_strategy::build_contractor(box const & box,
scoped_vec<shared_ptr<constraint>> const & ctrs,
bool const complete,
SMTConfig const & config) const {
bool const use_cache = true;
// 1. Categorize constraints
vector<shared_ptr<nonlinear_constraint>> nl_ctrs;
vector<shared_ptr<ode_constraint>> ode_ctrs_rev;
vector<shared_ptr<generic_forall_constraint>> generic_forall_ctrs;
for (shared_ptr<constraint> const ctr : ctrs.get_reverse()) {
switch (ctr->get_type()) {
case constraint_type::Nonlinear: {
auto nl_ctr = dynamic_pointer_cast<nonlinear_constraint>(ctr);
nl_ctrs.push_back(nl_ctr);
break;
}
case constraint_type::ODE: {
auto ode_ctr = dynamic_pointer_cast<ode_constraint>(ctr);
ode_ctrs_rev.push_back(ode_ctr);
break;
}
case constraint_type::GenericForall: {
auto gf_ctr = dynamic_pointer_cast<generic_forall_constraint>(ctr);
generic_forall_ctrs.push_back(gf_ctr);
break;
}
case constraint_type::ForallT: {
// Do nothing
break;
}
default:
DREAL_LOG_FATAL << "Unknown Constraint Type: " << ctr->get_type() << " " << *ctr << endl;
}
}
vector<shared_ptr<ode_constraint>> ode_ctrs(ode_ctrs_rev);
reverse(ode_ctrs.begin(), ode_ctrs.end());
vector<contractor> ctcs;
ctcs.reserve(ctrs.size());
// 2.0 Build Sample Contractor
if (config.nra_sample > 0 && complete) {
ctcs.push_back(mk_contractor_sample(box, config.nra_sample, ctrs.get_vec()));
}
// 2.1 Build nonlinear contractors
vector<contractor> nl_ctcs;
for (auto const & nl_ctr : nl_ctrs) {
if (!nl_ctr->is_neq()) {
nl_ctcs.push_back(mk_contractor_ibex_fwdbwd(nl_ctr, use_cache));
} else {
// Case: != (not equal), do nothing
}
}
contractor nl_ctc = mk_contractor_seq(nl_ctcs);
ctcs.insert(ctcs.end(), nl_ctcs.begin(), nl_ctcs.end());
// 2.2. Build Polytope Contractor
if (config.nra_polytope) {
ctcs.push_back(mk_contractor_ibex_polytope(config.nra_precision, box.get_vars(), nl_ctrs));
}
// 2.3. Int Contractor
ctcs.push_back(mk_contractor_int(box));
// 2.4. Build generic forall contractors
for (auto const & generic_forall_ctr : generic_forall_ctrs) {
ctcs.push_back(mk_contractor_generic_forall(box, generic_forall_ctr));
}
if (complete && ode_ctrs.size() > 0) {
// Add ODE Contractors only for complete check
// 2.5. Build GSL Contractors (using CAPD4)
vector<contractor> ode_gsl_ctcs;
if (config.nra_ODE_sampling) {
// 2.5.1 Build Eval contractors
vector<contractor> eval_ctcs;
for (auto const & nl_ctr : nl_ctrs) {
eval_ctcs.push_back(mk_contractor_eval(nl_ctr, false));
}
contractor eval_ctc = mk_contractor_seq(eval_ctcs);
if (config.nra_parallel) {
vector<contractor> nl_ctcs2;
for (auto const & nl_ctr : nl_ctrs) {
if (!nl_ctr->is_neq()) {
nl_ctcs2.push_back(mk_contractor_ibex_fwdbwd(nl_ctr, false));
} else {
// Case: != (not equal), do nothing
}
}
contractor nl_ctc2 = mk_contractor_seq(nl_ctcs2);
for (auto const & ode_ctr : ode_ctrs) {
// Add Forward ODE Pruning (Underapproximation, using GNU GSL)
ode_gsl_ctcs.push_back(mk_contractor_gsl(box, ode_ctr, eval_ctc, ode_direction::FWD, false, config.nra_ODE_fwd_timeout));
ode_gsl_ctcs.push_back(nl_ctc2);
}
} else {
for (auto const & ode_ctr : ode_ctrs) {
// Add Forward ODE Pruning (Underapproximation, using GNU GSL)
ode_gsl_ctcs.push_back(mk_contractor_gsl(box, ode_ctr, eval_ctc, ode_direction::FWD, use_cache, config.nra_ODE_fwd_timeout));
ode_gsl_ctcs.push_back(nl_ctc);
}
}
}
// 2.6. Build ODE Contractors (using CAPD4)
vector<contractor> ode_capd4_fwd_ctcs;
vector<contractor> ode_capd4_bwd_ctcs;
for (auto const & ode_ctr : ode_ctrs) {
// 2.6.1. Add Forward ODE Pruning (Overapproximation, using CAPD4)
if (config.nra_ODE_cache) {
ode_capd4_fwd_ctcs.emplace_back(
mk_contractor_cache(
mk_contractor_try(
mk_contractor_seq(mk_contractor_capd_full(box, ode_ctr, ode_direction::FWD, config.nra_ODE_taylor_order, config.nra_ODE_grid_size, use_cache, config.nra_ODE_fwd_timeout),
nl_ctc))));
} else {
ode_capd4_fwd_ctcs.emplace_back(
mk_contractor_try(
mk_contractor_seq(
mk_contractor_capd_full(box, ode_ctr, ode_direction::FWD, config.nra_ODE_taylor_order, config.nra_ODE_grid_size, use_cache, config.nra_ODE_fwd_timeout),
nl_ctc)));
}
}
if (!config.nra_ODE_forward_only) {
// 2.6.2. Add Backward ODE Pruning (Overapproximation, using CAPD4)
for (auto const & ode_ctr : ode_ctrs_rev) {
if (config.nra_ODE_cache) {
ode_capd4_bwd_ctcs.emplace_back(
mk_contractor_cache(
mk_contractor_try(
mk_contractor_seq(
mk_contractor_capd_full(box, ode_ctr, ode_direction::BWD, config.nra_ODE_taylor_order, config.nra_ODE_grid_size, use_cache, config.nra_ODE_bwd_timeout),
nl_ctc))));
} else {
ode_capd4_bwd_ctcs.emplace_back(
mk_contractor_try(
mk_contractor_seq(
mk_contractor_capd_full(box, ode_ctr, ode_direction::BWD, config.nra_ODE_taylor_order, config.nra_ODE_grid_size, use_cache, config.nra_ODE_bwd_timeout),
nl_ctc)));
}
}
}
if (config.nra_ODE_sampling) {
if (config.nra_parallel) {
ctcs.push_back(mk_contractor_parallel_any(
mk_contractor_try_or(mk_contractor_throw_if_empty(mk_contractor_seq(ode_gsl_ctcs)),
mk_contractor_empty()),
mk_contractor_seq(mk_contractor_seq(ode_capd4_fwd_ctcs),
mk_contractor_seq(ode_capd4_bwd_ctcs))));
} else {
ctcs.push_back(
mk_contractor_try_or(
// Try Underapproximation(GSL) if it fails try Overapproximation(CAPD4)
mk_contractor_throw_if_empty(mk_contractor_seq(ode_gsl_ctcs)),
mk_contractor_seq(mk_contractor_seq(ode_capd4_fwd_ctcs),
mk_contractor_seq(ode_capd4_bwd_ctcs))));
}
} else {
ctcs.insert(ctcs.end(), ode_capd4_fwd_ctcs.begin(), ode_capd4_fwd_ctcs.end());
ctcs.insert(ctcs.end(), ode_capd4_bwd_ctcs.begin(), ode_capd4_bwd_ctcs.end());
}
}
if (complete) {
// 2.7 Build Eval contractors
vector<contractor> eval_ctcs;
for (auto const & nl_ctr : nl_ctrs) {
eval_ctcs.push_back(mk_contractor_eval(nl_ctr, use_cache));
}
return mk_contractor_seq(mk_contractor_fixpoint(default_strategy::term_cond, ctcs),
mk_contractor_seq(eval_ctcs));
} else {
return mk_contractor_fixpoint(default_strategy::term_cond, ctcs);
}
}
