mirror of
https://github.com/Z3Prover/z3
synced 2025-04-07 18:05:21 +00:00
279 lines
8.6 KiB
C++
279 lines
8.6 KiB
C++
/*++
|
|
Copyright (c) 2011 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
theory_dl.h
|
|
|
|
Abstract:
|
|
|
|
Theory for DL constants.
|
|
DL constants are discrete and ordered by the linear order LT.
|
|
Constants have a parameter which indicates the numeric value that ranges
|
|
from 0 up to the size of the domain.
|
|
|
|
The procedure works by a simple reduction to bit-vectors. We enforce an injection into bit-vectors.
|
|
|
|
Author:
|
|
|
|
Nikolaj Bjorner (nbjorner) 2011-1-10
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include "smt_theory.h"
|
|
#include "dl_decl_plugin.h"
|
|
#include "value_factory.h"
|
|
#include "smt_model_generator.h"
|
|
#include "bv_decl_plugin.h"
|
|
#include "theory_bv.h"
|
|
#include "smt_context.h"
|
|
#include "ast_pp.h"
|
|
|
|
// Basic approach: reduce theory to bit-vectors:
|
|
//
|
|
// rep(c(n)) = n
|
|
// LT(x,y) <=> rep(x) < rep(y)
|
|
// val(rep(x)) = x
|
|
// 0 <= rep(x) <= max_value
|
|
//
|
|
|
|
|
|
namespace smt {
|
|
|
|
|
|
class dl_factory : public simple_factory<unsigned> {
|
|
datalog::dl_decl_util& m_util;
|
|
public:
|
|
dl_factory(datalog::dl_decl_util& u, proto_model& m):
|
|
simple_factory<unsigned>(u.get_manager(), u.get_family_id()),
|
|
m_util(u)
|
|
{}
|
|
|
|
virtual app * mk_value_core(unsigned const & val, sort * s) {
|
|
return m_util.mk_numeral(val, s);
|
|
}
|
|
};
|
|
|
|
class theory_dl : public theory {
|
|
datalog::dl_decl_util m_util;
|
|
bv_util m_bv;
|
|
ast_ref_vector m_trail;
|
|
obj_map<sort,func_decl*> m_reps;
|
|
obj_map<sort,func_decl*> m_vals;
|
|
|
|
ast_manager& m() { return get_manager(); }
|
|
datalog::dl_decl_util& u() { return m_util; }
|
|
bv_util& b() { return m_bv; }
|
|
|
|
class dl_value_proc : public smt::model_value_proc {
|
|
smt::model_generator & m_mg;
|
|
theory_dl& m_th;
|
|
smt::enode* m_node;
|
|
public:
|
|
|
|
dl_value_proc(smt::model_generator & m, theory_dl& th, smt::enode* n):
|
|
m_mg(m), m_th(th), m_node(n)
|
|
{ }
|
|
|
|
virtual void get_dependencies(buffer<smt::model_value_dependency> & result) {}
|
|
|
|
virtual app * mk_value(smt::model_generator & mg, ptr_vector<expr> & ) {
|
|
smt::context& ctx = m_th.get_context();
|
|
app* result = 0;
|
|
expr* n = m_node->get_owner();
|
|
sort* s = m_th.m().get_sort(n);
|
|
func_decl* r, *v;
|
|
m_th.get_rep(s, r, v);
|
|
app_ref rep_of(m_th.m());
|
|
rep_of = m_th.m().mk_app(r, m_node->get_owner());
|
|
theory_id bv_id = m_th.m().get_family_id("bv");
|
|
theory_bv* th_bv = dynamic_cast<theory_bv*>(ctx.get_theory(bv_id));
|
|
SASSERT(th_bv);
|
|
rational val;
|
|
if (ctx.e_internalized(rep_of) && th_bv &&
|
|
th_bv->get_fixed_value(rep_of.get(), val)) {
|
|
result = m_th.u().mk_numeral(val.get_int64(), s);
|
|
}
|
|
else {
|
|
result = m_th.u().mk_numeral(0, s);
|
|
}
|
|
TRACE("theory_dl", tout << mk_pp(result, m_th.m()) << "\n";);
|
|
return result;
|
|
}
|
|
};
|
|
|
|
public:
|
|
theory_dl(ast_manager& m):
|
|
theory(m.get_family_id("datalog_relation")),
|
|
m_util(m),
|
|
m_bv(m),
|
|
m_trail(m)
|
|
{
|
|
}
|
|
|
|
|
|
virtual char const * get_name() const { return "datalog"; }
|
|
|
|
virtual bool internalize_atom(app * atom, bool gate_ctx) {
|
|
TRACE("theory_dl", tout << mk_pp(atom, m()) << "\n";);
|
|
context& ctx = get_context();
|
|
if (ctx.b_internalized(atom)) {
|
|
return true;
|
|
}
|
|
switch(atom->get_decl_kind()) {
|
|
case datalog::OP_DL_LT: {
|
|
app* a = to_app(atom->get_arg(0));
|
|
app* b = to_app(atom->get_arg(1));
|
|
ctx.internalize(a, false);
|
|
ctx.internalize(b, false);
|
|
literal l(ctx.mk_bool_var(atom));
|
|
ctx.set_var_theory(l.var(), get_id());
|
|
mk_lt(a,b);
|
|
return true;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
virtual bool internalize_term(app * term) {
|
|
TRACE("theory_dl", tout << mk_pp(term, m()) << "\n";);
|
|
if (u().is_finite_sort(term)) {
|
|
return mk_rep(term);
|
|
}
|
|
else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
virtual void new_eq_eh(theory_var v1, theory_var v2) {
|
|
|
|
}
|
|
|
|
virtual void new_diseq_eh(theory_var v1, theory_var v2) {
|
|
|
|
}
|
|
|
|
virtual theory * mk_fresh(context * new_ctx) {
|
|
return alloc(theory_dl, get_manager());
|
|
}
|
|
|
|
virtual void init_model(smt::model_generator & m) {
|
|
m.register_factory(alloc(dl_factory, m_util, m.get_model()));
|
|
}
|
|
|
|
virtual smt::model_value_proc * mk_value(smt::enode * n, smt::model_generator & m) {
|
|
return alloc(dl_value_proc, m, *this, n);
|
|
}
|
|
|
|
virtual void apply_sort_cnstr(enode * n, sort * s) {
|
|
app* term = n->get_owner();
|
|
if (u().is_finite_sort(term)) {
|
|
mk_rep(term);
|
|
}
|
|
}
|
|
|
|
|
|
virtual void relevant_eh(app * n) {
|
|
if (u().is_finite_sort(n)) {
|
|
sort* s = m().get_sort(n);
|
|
func_decl* r, *v;
|
|
get_rep(s, r, v);
|
|
|
|
if (n->get_decl() != v) {
|
|
expr* rep = m().mk_app(r, n);
|
|
uint64 vl;
|
|
if (u().is_numeral_ext(n, vl)) {
|
|
assert_cnstr(m().mk_eq(rep, mk_bv_constant(vl, s)));
|
|
}
|
|
else {
|
|
assert_cnstr(m().mk_eq(m().mk_app(v,rep), n));
|
|
assert_cnstr(b().mk_ule(rep, max_value(s)));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
private:
|
|
|
|
void get_rep(sort* s, func_decl*& r, func_decl*& v) {
|
|
if(!m_reps.find(s, r) || !m_vals.find(s,v)) {
|
|
SASSERT(!m_reps.contains(s));
|
|
sort* bv = b().mk_sort(64);
|
|
// TBD: filter these from model.
|
|
r = m().mk_fresh_func_decl("rep",1, &s,bv);
|
|
v = m().mk_fresh_func_decl("val",1, &bv,s);
|
|
m_reps.insert(s, r);
|
|
m_vals.insert(s, v);
|
|
add_trail(r);
|
|
add_trail(v);
|
|
get_context().push_trail(insert_obj_map<context,sort,func_decl*>(m_reps, s));
|
|
get_context().push_trail(insert_obj_map<context,sort,func_decl*>(m_vals, s));
|
|
}
|
|
}
|
|
|
|
bool mk_rep(app* n) {
|
|
context & ctx = get_context();
|
|
unsigned num_args = n->get_num_args();
|
|
enode * e = 0;
|
|
for (unsigned i = 0; i < num_args; i++) {
|
|
ctx.internalize(n->get_arg(i), false);
|
|
}
|
|
if (ctx.e_internalized(n)) {
|
|
e = ctx.get_enode(n);
|
|
}
|
|
else {
|
|
e = ctx.mk_enode(n, false, false, true);
|
|
}
|
|
if (is_attached_to_var(e)) {
|
|
return false;
|
|
}
|
|
TRACE("theory_dl", tout << mk_pp(n, m()) << "\n";);
|
|
theory_var var = mk_var(e);
|
|
ctx.attach_th_var(e, this, var);
|
|
return true;
|
|
}
|
|
|
|
app* mk_bv_constant(uint64 val, sort* s) {
|
|
return b().mk_numeral(rational(val,rational::ui64()),64);
|
|
}
|
|
|
|
app* max_value(sort* s) {
|
|
uint64 sz;
|
|
VERIFY(u().try_get_size(s, sz));
|
|
return mk_bv_constant(sz, s);
|
|
}
|
|
|
|
void mk_lt(app* x, app* y) {
|
|
sort* s = m().get_sort(x);
|
|
func_decl* r, *v;
|
|
get_rep(s, r, v);
|
|
app* lt1 = u().mk_lt(x,y);
|
|
app* lt2 = m().mk_not(b().mk_ule(m().mk_app(r,y),m().mk_app(r,x)));
|
|
assert_cnstr(m().mk_iff(lt1, lt2));
|
|
}
|
|
|
|
void assert_cnstr(expr* e) {
|
|
TRACE("theory_dl", tout << mk_pp(e, m()) << "\n";);
|
|
context& ctx = get_context();
|
|
ctx.internalize(e, false);
|
|
literal lit(ctx.get_literal(e));
|
|
ctx.mark_as_relevant(lit);
|
|
ctx.mk_th_axiom(get_id(), 1, &lit);
|
|
}
|
|
|
|
void add_trail(ast* a) {
|
|
m_trail.push_back(a);
|
|
get_context().push_trail(push_back_vector<context,ast_ref_vector>(m_trail));
|
|
}
|
|
|
|
};
|
|
|
|
theory* mk_theory_dl(ast_manager& m) { return alloc(theory_dl, m); }
|
|
|
|
};
|