mirror of
https://github.com/Z3Prover/z3
synced 2025-04-10 19:27:06 +00:00
325 lines
9.7 KiB
C++
325 lines
9.7 KiB
C++
/*++
|
|
Copyright (c) 2006 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
user_smt_theory.h
|
|
|
|
Abstract:
|
|
|
|
<abstract>
|
|
|
|
Author:
|
|
|
|
Leonardo de Moura (leonardo) 2010-05-22.
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
#ifndef _USER_SMT_THEORY_H_
|
|
#define _USER_SMT_THEORY_H_
|
|
|
|
#include"user_decl_plugin.h"
|
|
#include"user_simplifier_plugin.h"
|
|
#include"smt_theory.h"
|
|
#include"union_find.h"
|
|
#include"smt_solver.h"
|
|
|
|
namespace smt {
|
|
|
|
class user_theory;
|
|
typedef int Z3_bool;
|
|
|
|
typedef void (*theory_callback_fptr)(user_theory * th);
|
|
typedef Z3_bool (*theory_final_check_callback_fptr)(user_theory * th);
|
|
typedef void (*theory_app_callback_fptr)(user_theory * th, app *);
|
|
typedef void (*theory_app_bool_callback_fptr)(user_theory * th, app *, Z3_bool);
|
|
typedef void (*theory_app_app_callback_fptr)(user_theory * th, app *, app *);
|
|
typedef void * (*theory_mk_fresh_ext_data_fptr)(user_theory * th);
|
|
|
|
class user_theory : public theory {
|
|
|
|
typedef trail_stack<user_theory> th_trail_stack;
|
|
typedef union_find<user_theory> th_union_find;
|
|
typedef std::pair<theory_var, theory_var> var_pair;
|
|
|
|
front_end_params const& m_params;
|
|
void * m_ext_context;
|
|
void * m_ext_data;
|
|
std::string m_name;
|
|
bool m_simplify_axioms;
|
|
user_decl_plugin * m_decl_plugin;
|
|
user_simplifier_plugin * m_simplifier_plugin;
|
|
|
|
th_union_find m_find;
|
|
th_trail_stack m_trail_stack;
|
|
|
|
svector<var_pair> m_new_eqs;
|
|
svector<var_pair> m_new_diseqs;
|
|
svector<bool_var> m_new_assignments;
|
|
ptr_vector<app> m_new_relevant_apps;
|
|
obj_hashtable<expr> m_asserted_axiom_set;
|
|
expr_ref_vector m_asserted_axioms;
|
|
ptr_vector<app> m_parents;
|
|
ptr_vector<ptr_vector<app> > m_use_list;
|
|
|
|
app_ref_vector m_persisted_axioms;
|
|
unsigned m_persisted_axioms_qhead;
|
|
|
|
struct scope {
|
|
unsigned m_asserted_axioms_old_sz;
|
|
unsigned m_parents_old_sz;
|
|
};
|
|
|
|
svector<scope> m_scopes;
|
|
|
|
theory_callback_fptr m_delete_fptr;
|
|
theory_app_callback_fptr m_new_app_fptr;
|
|
theory_app_callback_fptr m_new_elem_fptr;
|
|
theory_callback_fptr m_init_search_fptr;
|
|
theory_callback_fptr m_push_fptr;
|
|
theory_callback_fptr m_pop_fptr;
|
|
theory_callback_fptr m_restart_fptr;
|
|
theory_callback_fptr m_reset_fptr;
|
|
theory_final_check_callback_fptr m_final_check_fptr;
|
|
theory_app_app_callback_fptr m_new_eq_fptr;
|
|
theory_app_app_callback_fptr m_new_diseq_fptr;
|
|
theory_app_bool_callback_fptr m_new_assignment_fptr;
|
|
theory_app_callback_fptr m_new_relevant_fptr;
|
|
theory_mk_fresh_ext_data_fptr m_mk_fresh_fptr;
|
|
|
|
|
|
bool m_delete_invoking;
|
|
bool m_new_app_invoking;
|
|
bool m_new_elem_invoking;
|
|
bool m_init_search_invoking;
|
|
bool m_push_invoking;
|
|
bool m_pop_invoking;
|
|
bool m_restart_invoking;
|
|
bool m_reset_invoking;
|
|
bool m_final_check_invoking;
|
|
bool m_new_eq_invoking;
|
|
bool m_new_diseq_invoking;
|
|
bool m_new_assignment_invoking;
|
|
bool m_new_relevant_invoking;
|
|
|
|
struct statistics {
|
|
unsigned m_num_eq;
|
|
unsigned m_num_diseq;
|
|
unsigned m_num_assignment;
|
|
unsigned m_num_user_axioms;
|
|
statistics() { reset(); }
|
|
void reset() { memset(this, 0, sizeof(*this)); }
|
|
};
|
|
|
|
statistics m_stats;
|
|
|
|
protected:
|
|
virtual theory_var mk_var(enode * n);
|
|
|
|
literal internalize_literal(expr * arg);
|
|
|
|
void assert_axioms_into_context(unsigned old_sz);
|
|
|
|
void assert_axiom_into_context(expr * axiom);
|
|
|
|
void reset_propagation_queues();
|
|
|
|
void shrink_use_list(unsigned sz);
|
|
|
|
ptr_vector<app> * get_non_null_use_list(theory_var v);
|
|
|
|
void mark_as_relevant(literal l);
|
|
|
|
void assert_axiom_core(app* axiom);
|
|
|
|
public:
|
|
user_theory(ast_manager & m, front_end_params const& p, void * ext_context, void * ext_data, char const * name, family_id fid, user_decl_plugin * dp, user_simplifier_plugin * sp);
|
|
virtual ~user_theory();
|
|
|
|
virtual theory * mk_fresh(context * new_ctx);
|
|
|
|
void * get_ext_context() const {
|
|
return m_ext_context;
|
|
}
|
|
|
|
void * get_ext_data() {
|
|
return m_ext_data;
|
|
}
|
|
|
|
sort * mk_sort(symbol const & name) {
|
|
return m_decl_plugin->mk_sort(name);
|
|
}
|
|
|
|
func_decl * mk_func_decl(symbol const & name, unsigned arity, sort * const * domain, sort * range) {
|
|
return m_decl_plugin->mk_func_decl(name, arity, domain, range);
|
|
}
|
|
|
|
func_decl * mk_value_decl(symbol const & name, sort * s) {
|
|
return m_decl_plugin->mk_value_decl(name, s);
|
|
}
|
|
|
|
void assert_axiom(ast * axiom);
|
|
|
|
void assume_eq(ast * lhs, ast * rhs);
|
|
|
|
void enable_axiom_simplification(bool flag) {
|
|
m_simplify_axioms = flag;
|
|
}
|
|
|
|
void set_delete_fptr(theory_callback_fptr ptr) {
|
|
m_delete_fptr = ptr;
|
|
}
|
|
|
|
void set_reduce_app_fptr(reduce_app_fptr ptr) {
|
|
m_simplifier_plugin->set_reduce_app_fptr(ptr);
|
|
}
|
|
|
|
void set_reduce_eq_fptr(reduce_eq_fptr ptr) {
|
|
m_simplifier_plugin->set_reduce_eq_fptr(ptr);
|
|
}
|
|
|
|
void set_reduce_distinct_fptr(reduce_distinct_fptr ptr) {
|
|
m_simplifier_plugin->set_reduce_distinct_fptr(ptr);
|
|
}
|
|
|
|
void set_new_app_fptr(theory_app_callback_fptr ptr) {
|
|
m_new_app_fptr = ptr;
|
|
}
|
|
|
|
void set_new_elem_fptr(theory_app_callback_fptr ptr) {
|
|
m_new_elem_fptr = ptr;
|
|
}
|
|
|
|
void set_init_search_fptr(theory_callback_fptr ptr) {
|
|
m_init_search_fptr = ptr;
|
|
}
|
|
|
|
void set_push_fptr(theory_callback_fptr ptr) {
|
|
m_push_fptr = ptr;
|
|
}
|
|
|
|
void set_pop_fptr(theory_callback_fptr ptr) {
|
|
m_pop_fptr = ptr;
|
|
}
|
|
|
|
void set_restart_fptr(theory_callback_fptr ptr) {
|
|
m_restart_fptr = ptr;
|
|
}
|
|
|
|
void set_reset_fptr(theory_callback_fptr ptr) {
|
|
m_reset_fptr = ptr;
|
|
}
|
|
|
|
void set_final_check_fptr(theory_final_check_callback_fptr ptr) {
|
|
m_final_check_fptr = ptr;
|
|
}
|
|
|
|
void set_new_eq_fptr(theory_app_app_callback_fptr ptr) {
|
|
m_new_eq_fptr = ptr;
|
|
}
|
|
|
|
void set_new_diseq_fptr(theory_app_app_callback_fptr ptr) {
|
|
m_new_diseq_fptr = ptr;
|
|
}
|
|
|
|
void set_new_assignment_fptr(theory_app_bool_callback_fptr ptr) {
|
|
m_new_assignment_fptr = ptr;
|
|
}
|
|
|
|
void set_new_relevant_fptr(theory_app_callback_fptr ptr) {
|
|
m_new_relevant_fptr = ptr;
|
|
}
|
|
|
|
th_trail_stack & get_trail_stack() { return m_trail_stack; }
|
|
|
|
theory_var get_var(ast * n) const;
|
|
|
|
theory_var mk_var(ast * n);
|
|
|
|
ast * get_root(ast * n) const;
|
|
|
|
ast * get_next(ast * n) const;
|
|
|
|
unsigned get_num_parents(ast * n) const;
|
|
|
|
ast * get_parent(ast * n, unsigned i) const;
|
|
|
|
unsigned get_num_parents() const { return m_parents.size(); }
|
|
|
|
ast * get_parent(unsigned i) const { return m_parents[i]; }
|
|
|
|
unsigned get_num_apps() const { return get_num_vars(); }
|
|
|
|
app * get_app(unsigned i) const { return get_enode(i)->get_owner(); }
|
|
|
|
unsigned get_num_asts() const { return get_num_apps(); }
|
|
|
|
ast * get_ast(unsigned i) const { return get_app(i); }
|
|
|
|
static void merge_eh(theory_var, theory_var, theory_var, theory_var) {}
|
|
|
|
static void after_merge_eh(theory_var, theory_var, theory_var, theory_var) {}
|
|
|
|
virtual void unmerge_eh(theory_var, theory_var) {}
|
|
|
|
virtual bool internalize_atom(app * atom, bool gate_ctx);
|
|
|
|
virtual bool internalize_term(app * term);
|
|
|
|
virtual void apply_sort_cnstr(enode * n, sort * s);
|
|
|
|
virtual void assign_eh(bool_var v, bool is_true);
|
|
|
|
virtual void new_eq_eh(theory_var v1, theory_var v2);
|
|
|
|
virtual void new_diseq_eh(theory_var v1, theory_var v2);
|
|
|
|
virtual void relevant_eh(app * n);
|
|
|
|
virtual void push_scope_eh();
|
|
|
|
virtual void pop_scope_eh(unsigned num_scopes);
|
|
|
|
virtual void restart_eh();
|
|
|
|
virtual void init_search_eh();
|
|
|
|
virtual final_check_status final_check_eh();
|
|
|
|
virtual bool can_propagate();
|
|
|
|
virtual void propagate();
|
|
|
|
virtual void flush_eh();
|
|
|
|
virtual void reset_eh();
|
|
|
|
void reset(bool full_reset);
|
|
|
|
virtual void display_statistics(std::ostream & out) const;
|
|
|
|
virtual void display_istatistics(std::ostream & out) const;
|
|
|
|
virtual bool build_models() const;
|
|
|
|
virtual void init_model(model_generator & m);
|
|
|
|
virtual void finalize_model(model_generator & m);
|
|
|
|
virtual model_value_proc * mk_value(enode * n, model_generator & mg);
|
|
|
|
virtual bool get_value(enode * n, expr_ref & r);
|
|
|
|
virtual char const * get_name() const;
|
|
|
|
virtual void display(std::ostream & out) const;
|
|
};
|
|
|
|
user_theory * mk_user_theory(solver & s, void * ext_context, void * ext_data, char const * name);
|
|
};
|
|
|
|
|
|
#endif /* _USER_SMT_THEORY_H_ */
|
|
|