bool uses_theory(expr * n, family_id fid, expr_mark & visited) { uses_theory_ns::proc p(fid); try { for_each_expr(p, visited, n); } catch (uses_theory_ns::found) { return true; } return false; }
bool has_skolem_functions(expr * n) { has_skolem_functions_ns::proc p; try { for_each_expr(p, n); } catch (has_skolem_functions_ns::found) { return true; } return false; }
bool array_property_recognizer::operator()(unsigned num_fmls, expr* const* fmls) { is_array_property_ns::proc p(m_manager); try { for (unsigned i = 0; i < num_fmls; ++i) { for_each_expr(p, fmls[i]); } } catch (is_array_property_ns::bad) { return false; } return p.has_quantifier(); }
bool simplify(goal_ref const& g, pb_preproc_model_converter& mc) { reset(); normalize(g); if (g->inconsistent()) { return false; } for (unsigned i = 0; i < g->size(); ++i) { process_vars(i, g); } if (m_ge.empty()) { return false; } for (unsigned i = 0; i < m_ge.size(); ++i) { classify_vars(i, to_app(g->form(m_ge[i]))); } declassifier dcl(m_vars); expr_mark visited; for (unsigned i = 0; !m_vars.empty() && i < m_other.size(); ++i) { for_each_expr(dcl, visited, g->form(m_other[i])); } if (m_vars.empty()) { return false; } // display_annotation(tout, g); m_progress = false; // first eliminate variables var_map::iterator it = next_resolvent(m_vars.begin()); while (it != m_vars.end()) { app * e = it->m_key; rec const& r = it->m_value; TRACE("pb", tout << mk_pp(e, m) << " " << r.pos.size() << " " << r.neg.size() << "\n";); if (r.pos.empty()) { replace(r.neg, e, m.mk_false(), g); mc.set_value(e, false); } else if (r.neg.empty()) { replace(r.pos, e, m.mk_true(), g); mc.set_value(e, true); } if (g->inconsistent()) return false; ++it; it = next_resolvent(it); }
void array_property_expander::operator()(unsigned num_fmls, expr* const* fmls, expr_ref_vector& result) { ast_manager& m = m_manager; unsigned offset = 0; for (unsigned i = 0; i < num_fmls; ++i) { bool change = false; expr_ref e(m); result.push_back(fmls[i]); do { array_property_exp::proc p(m, offset); e = result[i].get(); for_each_expr(p, e); result[i] = p.find(e); change = e != result[i].get(); } while (change); } }
bool pattern_validator::process(uint_set & found_vars, unsigned num_bindings, unsigned num_new_bindings, expr * n) { // I'm traversing the DAG as a tree, this is not a problem since pattern are supposed to be small ASTs. if (n->get_kind() == AST_VAR) { warning_msg("invalid pattern: variable."); return false; } pattern_validation_functor f(found_vars, num_bindings, num_new_bindings, m_bfid, m_lfid); for_each_expr(f, n); if (!f.m_result) return false; if (!f.m_found_a_var) { warning_msg("pattern does not contain any variable."); return false; } return true; }
void operator()(goal_ref const & g, goal_ref_buffer & result, model_converter_ref & mc, proof_converter_ref & pc, expr_dependency_ref & core) override { mc = nullptr; tactic_report report("collect-statistics", *g); collect_proc cp(m, m_stats); expr_mark visited; const unsigned sz = g->size(); for (unsigned i = 0; i < sz; i++) for_each_expr(cp, visited, g->form(i)); std::cout << "(" << std::endl; stats_type::iterator it = m_stats.begin(); stats_type::iterator end = m_stats.end(); for (; it != end; it++) std::cout << " :" << it->first << " " << it->second << std::endl; std::cout << ")" << std::endl; g->inc_depth(); result.push_back(g.get()); }
unsigned get_num_exprs(expr * n, expr_mark & visited) { expr_counter_proc counter; for_each_expr(counter, visited, n); return counter.m_num; }
void apply(expr_ref& e) { for_each_expr(*this, e); e = get_expr(e); }
quantifier * find_quantifier(expr * n) { find_q::proc p; for_each_expr(p, n); return p.m_q; }
void collect_func_decls(ast_manager & m, expr * n, func_decl_set & r, bool ng_only) { collect_dependencies_proc proc(m, r, ng_only); for_each_expr(proc, n); }