mirror of
https://github.com/Z3Prover/z3
synced 2025-04-08 18:31:49 +00:00
358 lines
9.1 KiB
C++
358 lines
9.1 KiB
C++
/*++
|
|
Copyright (c) 2012 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
smt_solver.h
|
|
|
|
Abstract:
|
|
|
|
New frontend for the incremental solver.
|
|
|
|
Author:
|
|
|
|
Leonardo de Moura (leonardo) 2012-02-09.
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
#include"smt_solver.h"
|
|
#include"smt_context.h"
|
|
#include"ast_smt2_pp.h"
|
|
#include"params2front_end_params.h"
|
|
|
|
namespace smt {
|
|
|
|
struct solver::imp {
|
|
smt::context m_kernel;
|
|
params_ref m_params;
|
|
|
|
imp(ast_manager & m, front_end_params & fp, params_ref const & p):
|
|
m_kernel(m, fp, p),
|
|
m_params(p) {
|
|
}
|
|
|
|
front_end_params & fparams() {
|
|
return m_kernel.get_fparams();
|
|
}
|
|
|
|
params_ref const & params() {
|
|
return m_params;
|
|
}
|
|
|
|
ast_manager & m() const {
|
|
return m_kernel.get_manager();
|
|
}
|
|
|
|
bool set_logic(symbol logic) {
|
|
return m_kernel.set_logic(logic);
|
|
}
|
|
|
|
void set_progress_callback(progress_callback * callback) {
|
|
return m_kernel.set_progress_callback(callback);
|
|
}
|
|
|
|
void assert_expr(expr * e) {
|
|
TRACE("smt_solver", tout << "assert:\n" << mk_ismt2_pp(e, m()) << "\n";);
|
|
m_kernel.assert_expr(e);
|
|
}
|
|
|
|
void assert_expr(expr * e, proof * pr) {
|
|
m_kernel.assert_expr(e, pr);
|
|
}
|
|
|
|
unsigned size() const {
|
|
return m_kernel.get_num_asserted_formulas();
|
|
}
|
|
|
|
expr * const * get_formulas() const {
|
|
return m_kernel.get_asserted_formulas();
|
|
}
|
|
|
|
bool reduce() {
|
|
return m_kernel.reduce_assertions();
|
|
}
|
|
|
|
void push() {
|
|
TRACE("smt_solver", tout << "push()\n";);
|
|
m_kernel.push();
|
|
}
|
|
|
|
void pop(unsigned num_scopes) {
|
|
TRACE("smt_solver", tout << "pop()\n";);
|
|
m_kernel.pop(num_scopes);
|
|
}
|
|
|
|
unsigned get_scope_level() const {
|
|
return m_kernel.get_scope_level();
|
|
}
|
|
|
|
lbool setup_and_check() {
|
|
return m_kernel.setup_and_check();
|
|
}
|
|
|
|
bool inconsistent() {
|
|
return m_kernel.inconsistent();
|
|
}
|
|
|
|
lbool check(unsigned num_assumptions, expr * const * assumptions) {
|
|
return m_kernel.check(num_assumptions, assumptions);
|
|
}
|
|
|
|
void get_model(model_ref & m) const {
|
|
m_kernel.get_model(m);
|
|
}
|
|
|
|
proof * get_proof() {
|
|
return m_kernel.get_proof();
|
|
}
|
|
|
|
unsigned get_unsat_core_size() const {
|
|
return m_kernel.get_unsat_core_size();
|
|
}
|
|
|
|
expr * get_unsat_core_expr(unsigned idx) const {
|
|
return m_kernel.get_unsat_core_expr(idx);
|
|
}
|
|
|
|
failure last_failure() const {
|
|
return m_kernel.get_last_search_failure();
|
|
}
|
|
|
|
std::string last_failure_as_string() const {
|
|
return m_kernel.last_failure_as_string();
|
|
}
|
|
|
|
void get_assignments(expr_ref_vector & result) {
|
|
m_kernel.get_assignments(result);
|
|
}
|
|
|
|
void get_relevant_labels(expr * cnstr, buffer<symbol> & result) {
|
|
m_kernel.get_relevant_labels(cnstr, result);
|
|
}
|
|
|
|
void get_relevant_labeled_literals(bool at_lbls, expr_ref_vector & result) {
|
|
m_kernel.get_relevant_labeled_literals(at_lbls, result);
|
|
}
|
|
|
|
void get_relevant_literals(expr_ref_vector & result) {
|
|
m_kernel.get_relevant_literals(result);
|
|
}
|
|
|
|
void get_guessed_literals(expr_ref_vector & result) {
|
|
m_kernel.get_guessed_literals(result);
|
|
}
|
|
|
|
void display(std::ostream & out) const {
|
|
// m_kernel.display(out); <<< for external users it is just junk
|
|
// TODO: it will be replaced with assertion_stack.display
|
|
unsigned num = m_kernel.get_num_asserted_formulas();
|
|
expr * const * fms = m_kernel.get_asserted_formulas();
|
|
out << "(solver";
|
|
for (unsigned i = 0; i < num; i++) {
|
|
out << "\n " << mk_ismt2_pp(fms[i], m(), 2);
|
|
}
|
|
out << ")";
|
|
}
|
|
|
|
void collect_statistics(::statistics & st) const {
|
|
m_kernel.collect_statistics(st);
|
|
}
|
|
|
|
void reset_statistics() {
|
|
}
|
|
|
|
void display_statistics(std::ostream & out) const {
|
|
m_kernel.display_statistics(out);
|
|
}
|
|
|
|
void display_istatistics(std::ostream & out) const {
|
|
m_kernel.display_istatistics(out);
|
|
}
|
|
|
|
void set_cancel(bool f) {
|
|
m_kernel.set_cancel_flag(f);
|
|
}
|
|
|
|
bool canceled() {
|
|
return m_kernel.get_cancel_flag();
|
|
}
|
|
|
|
void updt_params(params_ref const & p) {
|
|
params2front_end_params(p, fparams());
|
|
}
|
|
|
|
void collect_param_descrs(param_descrs & d) {
|
|
solver_front_end_params_descrs(d);
|
|
}
|
|
};
|
|
|
|
solver::solver(ast_manager & m, front_end_params & fp, params_ref const & p) {
|
|
m_imp = alloc(imp, m, fp, p);
|
|
}
|
|
|
|
solver::~solver() {
|
|
dealloc(m_imp);
|
|
}
|
|
|
|
ast_manager & solver::m() const {
|
|
return m_imp->m();
|
|
}
|
|
|
|
bool solver::set_logic(symbol logic) {
|
|
return m_imp->set_logic(logic);
|
|
}
|
|
|
|
void solver::set_progress_callback(progress_callback * callback) {
|
|
m_imp->set_progress_callback(callback);
|
|
}
|
|
|
|
void solver::assert_expr(expr * e) {
|
|
m_imp->assert_expr(e);
|
|
}
|
|
|
|
void solver::assert_expr(expr * e, proof * pr) {
|
|
m_imp->assert_expr(e, pr);
|
|
}
|
|
|
|
unsigned solver::size() const {
|
|
return m_imp->size();
|
|
}
|
|
|
|
expr * const * solver::get_formulas() const {
|
|
return m_imp->get_formulas();
|
|
}
|
|
|
|
bool solver::reduce() {
|
|
return m_imp->reduce();
|
|
}
|
|
|
|
void solver::push() {
|
|
m_imp->push();
|
|
}
|
|
|
|
void solver::pop(unsigned num_scopes) {
|
|
m_imp->pop(num_scopes);
|
|
}
|
|
|
|
unsigned solver::get_scope_level() const {
|
|
return m_imp->get_scope_level();
|
|
}
|
|
|
|
void solver::reset() {
|
|
ast_manager & _m = m();
|
|
front_end_params & fps = m_imp->fparams();
|
|
params_ref ps = m_imp->params();
|
|
#pragma omp critical (smt_solver)
|
|
{
|
|
dealloc(m_imp);
|
|
m_imp = alloc(imp, _m, fps, ps);
|
|
}
|
|
}
|
|
|
|
bool solver::inconsistent() {
|
|
return m_imp->inconsistent();
|
|
}
|
|
|
|
lbool solver::setup_and_check() {
|
|
set_cancel(false);
|
|
return m_imp->setup_and_check();
|
|
}
|
|
|
|
lbool solver::check(unsigned num_assumptions, expr * const * assumptions) {
|
|
set_cancel(false);
|
|
lbool r = m_imp->check(num_assumptions, assumptions);
|
|
TRACE("smt_solver", tout << "check result: " << r << "\n";);
|
|
return r;
|
|
}
|
|
|
|
void solver::get_model(model_ref & m) const {
|
|
m_imp->get_model(m);
|
|
}
|
|
|
|
proof * solver::get_proof() {
|
|
return m_imp->get_proof();
|
|
}
|
|
|
|
unsigned solver::get_unsat_core_size() const {
|
|
return m_imp->get_unsat_core_size();
|
|
}
|
|
|
|
expr * solver::get_unsat_core_expr(unsigned idx) const {
|
|
return m_imp->get_unsat_core_expr(idx);
|
|
}
|
|
|
|
failure solver::last_failure() const {
|
|
return m_imp->last_failure();
|
|
}
|
|
|
|
std::string solver::last_failure_as_string() const {
|
|
return m_imp->last_failure_as_string();
|
|
}
|
|
|
|
void solver::get_assignments(expr_ref_vector & result) {
|
|
m_imp->get_assignments(result);
|
|
}
|
|
|
|
void solver::get_relevant_labels(expr * cnstr, buffer<symbol> & result) {
|
|
m_imp->get_relevant_labels(cnstr, result);
|
|
}
|
|
|
|
void solver::get_relevant_labeled_literals(bool at_lbls, expr_ref_vector & result) {
|
|
m_imp->get_relevant_labeled_literals(at_lbls, result);
|
|
}
|
|
|
|
void solver::get_relevant_literals(expr_ref_vector & result) {
|
|
m_imp->get_relevant_literals(result);
|
|
}
|
|
|
|
void solver::get_guessed_literals(expr_ref_vector & result) {
|
|
m_imp->get_guessed_literals(result);
|
|
}
|
|
|
|
void solver::display(std::ostream & out) const {
|
|
m_imp->display(out);
|
|
}
|
|
|
|
void solver::collect_statistics(::statistics & st) const {
|
|
m_imp->collect_statistics(st);
|
|
}
|
|
|
|
void solver::reset_statistics() {
|
|
m_imp->reset_statistics();
|
|
}
|
|
|
|
void solver::display_statistics(std::ostream & out) const {
|
|
m_imp->display_statistics(out);
|
|
}
|
|
|
|
void solver::display_istatistics(std::ostream & out) const {
|
|
m_imp->display_istatistics(out);
|
|
}
|
|
|
|
void solver::set_cancel(bool f) {
|
|
#pragma omp critical (smt_solver)
|
|
{
|
|
if (m_imp)
|
|
m_imp->set_cancel(f);
|
|
}
|
|
}
|
|
|
|
bool solver::canceled() const {
|
|
return m_imp->canceled();
|
|
}
|
|
|
|
void solver::updt_params(params_ref const & p) {
|
|
return m_imp->updt_params(p);
|
|
}
|
|
|
|
void solver::collect_param_descrs(param_descrs & d) const {
|
|
return m_imp->collect_param_descrs(d);
|
|
}
|
|
|
|
context & solver::kernel() {
|
|
return m_imp->m_kernel;
|
|
}
|
|
|
|
};
|