mirror of
https://github.com/Z3Prover/z3
synced 2025-04-23 17:15:31 +00:00
checkpoint
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
This commit is contained in:
Leonardo de Moura
parent
142bf71b35
commit
9359ab7ce5
124 changed files with 2 additions and 0 deletions
|
|
@ -1,208 +0,0 @@
|
|||
/*++
|
||||
Copyright (c) 2010 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
array_property_expander.cpp
|
||||
|
||||
Abstract:
|
||||
|
||||
Expand array operations for the array property fragment formulas.
|
||||
|
||||
Author:
|
||||
|
||||
Nikolaj Bjorner (nbjorner) 2010-16-12
|
||||
|
||||
Revision History:
|
||||
|
||||
--*/
|
||||
|
||||
#include"array_property_expander.h"
|
||||
#include"obj_hashtable.h"
|
||||
#include"var_subst.h"
|
||||
#include"array_decl_plugin.h"
|
||||
#include"for_each_expr.h"
|
||||
|
||||
array_property_expander::array_property_expander(ast_manager& m):
|
||||
m_manager(m) {
|
||||
}
|
||||
|
||||
namespace array_property_exp {
|
||||
class proc {
|
||||
ast_manager& m_manager;
|
||||
unsigned& m_offset;
|
||||
expr_ref_vector m_trail;
|
||||
family_id m_fid;
|
||||
array_util m_util;
|
||||
obj_map<expr, expr*> m_mem;
|
||||
|
||||
|
||||
void insert(expr* a, expr* b) {
|
||||
m_trail.push_back(b);
|
||||
m_mem.insert(a, b);
|
||||
}
|
||||
|
||||
|
||||
public:
|
||||
proc(ast_manager& m, unsigned& offset) :
|
||||
m_manager(m),
|
||||
m_offset(offset),
|
||||
m_trail(m),
|
||||
m_fid(m.get_family_id("array")),
|
||||
m_util(m)
|
||||
{}
|
||||
|
||||
expr* find(expr* e) {
|
||||
expr* result = 0;
|
||||
VERIFY(m_mem.find(e, result));
|
||||
return result;
|
||||
}
|
||||
|
||||
void operator()(var* n) { insert(n, n); }
|
||||
|
||||
void operator()(quantifier* q) {
|
||||
expr* e = find(q->get_expr());
|
||||
quantifier* q2 = m_manager.update_quantifier(q, e);
|
||||
insert(q, q2);
|
||||
}
|
||||
|
||||
void operator()(app* n) {
|
||||
ast_manager& m = m_manager;
|
||||
unsigned num_args = n->get_num_args();
|
||||
ptr_buffer<expr> args;
|
||||
for (unsigned i = 0; i < num_args; ++i) {
|
||||
args.push_back(find(n->get_arg(i)));
|
||||
}
|
||||
if (m_manager.is_eq(n) && m_util.is_array(args[0])) {
|
||||
visit_eq(n);
|
||||
return;
|
||||
}
|
||||
if (m_manager.is_distinct(n) && num_args > 0 && m_util.is_array(args[0])) {
|
||||
ptr_buffer<expr> eqs;
|
||||
for (unsigned i = 0; i < num_args; ++i) {
|
||||
for (unsigned j = i + 1; j < num_args; ++j) {
|
||||
eqs.push_back(m.mk_not(m.mk_eq(args[i], args[j])));
|
||||
}
|
||||
}
|
||||
insert(n, m.mk_and(eqs.size(), eqs.c_ptr()));
|
||||
return;
|
||||
}
|
||||
|
||||
if (m_util.is_select(n)) {
|
||||
SASSERT(num_args > 0);
|
||||
|
||||
// select(store(A,i,v),j) -> ite(i = j, v, select(A,j))
|
||||
if (m_util.is_store(args[0])) {
|
||||
app* a = to_app(args[0]);
|
||||
expr* b = find(a->get_arg(0));
|
||||
expr* v = find(a->get_arg(a->get_num_args()-1));
|
||||
ptr_buffer<expr> eqs;
|
||||
SASSERT(num_args + 1 == a->get_num_args());
|
||||
for (unsigned i = 1; i < num_args; ++i) {
|
||||
eqs.push_back(m.mk_eq(args[i], find(a->get_arg(i))));
|
||||
}
|
||||
expr* r = m.mk_ite(m.mk_and(eqs.size(), eqs.c_ptr()), v, mk_select(b, num_args-1, args.c_ptr()+1));
|
||||
insert(n, r);
|
||||
return;
|
||||
}
|
||||
|
||||
// select(ite(a,b,c),i) -> ite(a, select(b,i), select(c, i))
|
||||
if (m.is_ite(args[0])) {
|
||||
app* k = to_app(args[0]);
|
||||
expr* a = k->get_arg(0);
|
||||
expr* b = mk_select(k->get_arg(1), args.size()-1, args.c_ptr()+1);
|
||||
expr* c = mk_select(k->get_arg(2), args.size()-1, args.c_ptr()+1);
|
||||
expr* r = m.mk_ite(a, b, c);
|
||||
insert(n, r);
|
||||
return;
|
||||
}
|
||||
|
||||
// select(map_f(A,B),i) -> f(select(A,i), select(B,i))
|
||||
if (m_util.is_map(args[0])) {
|
||||
app* a = to_app(args[0]);
|
||||
func_decl* f = a->get_decl();
|
||||
SASSERT(f->get_num_parameters() == 1);
|
||||
SASSERT(f->get_parameter(0).is_ast());
|
||||
SASSERT(is_func_decl(f->get_parameter(0).get_ast()));
|
||||
parameter p = f->get_parameter(0);
|
||||
func_decl* d = to_func_decl(p.get_ast());
|
||||
ptr_buffer<expr> args2;
|
||||
for (unsigned i = 0; i < a->get_num_args(); ++i) {
|
||||
args2.push_back(mk_select(find(a->get_arg(i)), args.size()-1, args.c_ptr()+1));
|
||||
}
|
||||
expr* r = m.mk_app(d, args2.size(), args2.c_ptr());
|
||||
insert(n, r);
|
||||
return;
|
||||
}
|
||||
|
||||
// select(const v, i) -> v
|
||||
if (m_util.is_const(args[0])) {
|
||||
insert(n, to_app(args[0])->get_arg(0));
|
||||
return;
|
||||
}
|
||||
}
|
||||
expr* r = m_manager.mk_app(n->get_decl(), args.size(), args.c_ptr());
|
||||
insert(n, r);
|
||||
}
|
||||
|
||||
private:
|
||||
void visit_eq(app* eq) {
|
||||
ast_manager& m = m_manager;
|
||||
SASSERT(m.is_eq(eq));
|
||||
sort* s = m.get_sort(eq->get_arg(0));
|
||||
SASSERT(is_sort_of(s, m_fid, ARRAY_SORT));
|
||||
// sort* rng = get_array_range(s);
|
||||
unsigned arity = get_array_arity(s);
|
||||
shift_vars sh(m);
|
||||
expr_ref e1(m), e2(m);
|
||||
sh(find(eq->get_arg(0)), arity, e1);
|
||||
sh(find(eq->get_arg(1)), arity, e2);
|
||||
expr_ref_vector args(m);
|
||||
buffer<symbol> names;
|
||||
ptr_buffer<sort> sorts;
|
||||
args.push_back(e1);
|
||||
for (unsigned i = 0; i < arity; ++i) {
|
||||
args.push_back(m.mk_var(i, get_array_domain(s, i)));
|
||||
sorts.push_back(get_array_domain(s, arity - i - 1));
|
||||
names.push_back(symbol(m_offset++));
|
||||
}
|
||||
e1 = mk_select(args.size(), args.c_ptr());
|
||||
args[0] = e2;
|
||||
e2 = mk_select(args.size(), args.c_ptr());
|
||||
e1 = m.mk_eq(e1, e2);
|
||||
|
||||
e1 = m.mk_quantifier(true, arity, sorts.c_ptr(), names.c_ptr(), e1, 1);
|
||||
insert(eq, e1);
|
||||
}
|
||||
|
||||
app* mk_select(unsigned n, expr* const* args) {
|
||||
return m_manager.mk_app(m_fid, OP_SELECT, 0, 0, n, args);
|
||||
}
|
||||
|
||||
app* mk_select(expr* a, unsigned n, expr* const* args) {
|
||||
ptr_buffer<expr> args2;
|
||||
args2.push_back(a);
|
||||
args2.append(n, args);
|
||||
return mk_select(n+1, args2.c_ptr());
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1,33 +0,0 @@
|
|||
/*++
|
||||
Copyright (c) 2010 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
array_property_expander.h
|
||||
|
||||
Abstract:
|
||||
|
||||
Expand array operations for the array property fragment formulas.
|
||||
|
||||
Author:
|
||||
|
||||
Nikolaj Bjorner (nbjorner) 2010-16-12
|
||||
|
||||
Revision History:
|
||||
|
||||
--*/
|
||||
#ifndef _ARRAY_PROPERTY_EXPANDER_H_
|
||||
#define _ARRAY_PROPERTY_EXPANDER_H_
|
||||
|
||||
#include"ast.h"
|
||||
|
||||
class array_property_expander {
|
||||
ast_manager& m_manager;
|
||||
public:
|
||||
array_property_expander(ast_manager& m);
|
||||
void operator()(unsigned num_fmls, expr* const* fmls, expr_ref_vector& result);
|
||||
};
|
||||
|
||||
|
||||
#endif /* _ARRAY_PROPERTY_EXPANDER_H_ */
|
||||
|
||||
|
|
@ -1,103 +0,0 @@
|
|||
/*++
|
||||
Copyright (c) 2010 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
array_property_recognizer.cpp
|
||||
|
||||
Abstract:
|
||||
|
||||
<abstract>
|
||||
|
||||
Author:
|
||||
|
||||
Nikolaj Bjorner (nbjorner) 2010-16-12
|
||||
|
||||
Revision History:
|
||||
|
||||
--*/
|
||||
|
||||
#include"array_decl_plugin.h"
|
||||
#include"array_property_recognizer.h"
|
||||
#include"for_each_expr.h"
|
||||
|
||||
|
||||
array_property_recognizer::array_property_recognizer(ast_manager& m):
|
||||
m_manager(m) {}
|
||||
|
||||
namespace is_array_property_ns {
|
||||
struct bad {};
|
||||
class proc {
|
||||
ast_manager& m_manager;
|
||||
family_id m_fid;
|
||||
bool m_has_quantifier;
|
||||
|
||||
void check_array_sort(expr* n) {
|
||||
if (is_sort_of(m_manager.get_sort(n), m_fid, ARRAY_SORT)) {
|
||||
throw bad();
|
||||
}
|
||||
}
|
||||
|
||||
public:
|
||||
proc(ast_manager& m) :
|
||||
m_manager(m),
|
||||
m_fid(m.get_family_id("array")),
|
||||
m_has_quantifier(false) {}
|
||||
|
||||
bool has_quantifier() const { return m_has_quantifier; }
|
||||
|
||||
void operator()(var* n) {
|
||||
check_array_sort(n);
|
||||
}
|
||||
|
||||
void operator()(quantifier * ) {
|
||||
m_has_quantifier = true;
|
||||
}
|
||||
|
||||
void operator()(app* n) {
|
||||
unsigned num_args = n->get_num_args();
|
||||
if (m_manager.is_eq(n) || m_manager.is_distinct(n)) {
|
||||
return;
|
||||
}
|
||||
family_id fid = n->get_family_id();
|
||||
if (fid == m_fid) {
|
||||
switch(n->get_decl_kind()) {
|
||||
case OP_STORE:
|
||||
for (unsigned i = 1; i + 1 < num_args; ++i) {
|
||||
check_array_sort(n->get_arg(i));
|
||||
}
|
||||
return;
|
||||
case OP_SELECT:
|
||||
for (unsigned i = 1; i < num_args; ++i) {
|
||||
check_array_sort(n->get_arg(i));
|
||||
}
|
||||
return;
|
||||
case OP_CONST_ARRAY:
|
||||
case OP_ARRAY_MAP:
|
||||
return;
|
||||
default:
|
||||
throw bad();
|
||||
}
|
||||
}
|
||||
// arrays cannot be arguments of other functions.
|
||||
for (unsigned i = 0; i < num_args; ++i) {
|
||||
check_array_sort(n->get_arg(i));
|
||||
}
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
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();
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -1,33 +0,0 @@
|
|||
/*++
|
||||
Copyright (c) 2010 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
array_property_recognizer.h
|
||||
|
||||
Abstract:
|
||||
|
||||
<abstract>
|
||||
|
||||
Author:
|
||||
|
||||
Nikolaj Bjorner (nbjorner) 2010-16-12
|
||||
|
||||
Revision History:
|
||||
|
||||
--*/
|
||||
#ifndef _ARRAY_PROPERTY_RECOGNIZER_H_
|
||||
#define _ARRAY_PROPERTY_RECOGNIZER_H_
|
||||
|
||||
#include"ast.h"
|
||||
|
||||
class array_property_recognizer {
|
||||
ast_manager& m_manager;
|
||||
public:
|
||||
array_property_recognizer(ast_manager& m);
|
||||
bool operator()(unsigned num_fmls, expr* const* fmls);
|
||||
};
|
||||
|
||||
|
||||
#endif /* _ARRAY_PROPERTY_RECOGNIZER_H_ */
|
||||
|
||||
42
src/dead/test/ackermanize.cpp
Normal file
42
src/dead/test/ackermanize.cpp
Normal file
|
|
@ -0,0 +1,42 @@
|
|||
#include "ackermanize.h"
|
||||
#include "smtparser.h"
|
||||
#include "ast_pp.h"
|
||||
|
||||
void tst_ackermanize()
|
||||
{
|
||||
ast_manager manager;
|
||||
|
||||
smtlib::parser* parser = smtlib::parser::create(manager);
|
||||
ackermanize ack(manager);
|
||||
|
||||
ast_ref<const_decl_ast> fD(manager);
|
||||
ast_ref<const_decl_ast> xD(manager);
|
||||
ast_ref<type_decl_ast> AD(manager);
|
||||
ast_ref<type_ast> A(manager);
|
||||
ast_ref<> a1(manager), a2(manager), a3(manager), a4(manager),
|
||||
a5(manager), a6(manager), a7(manager);
|
||||
ast_ref<> r(manager);
|
||||
|
||||
AD = manager.mk_type_decl(symbol("A"));
|
||||
A = manager.mk_type(AD.get());
|
||||
fD = manager.mk_const_decl(symbol("f"), A.get(), A.get(), A.get());
|
||||
a1 = manager.mk_const(manager.mk_const_decl(symbol("a1"), A.get()));
|
||||
a2 = manager.mk_const(manager.mk_const_decl(symbol("a2"), A.get()));
|
||||
a3 = manager.mk_const(manager.mk_const_decl(symbol("a3"), A.get()));
|
||||
a4 = manager.mk_const(manager.mk_const_decl(symbol("a4"), A.get()));
|
||||
a5 = manager.mk_const(manager.mk_const_decl(symbol("a5"), A.get()));
|
||||
a6 = manager.mk_const(manager.mk_const_decl(symbol("a6"), A.get()));
|
||||
a7 = manager.mk_const(manager.mk_const_decl(symbol("a7"), A.get()));
|
||||
|
||||
r = manager.mk_const(manager.get_basic_family_id(),
|
||||
OP_EQ,
|
||||
manager.mk_const(fD.get(), a1.get(), a2.get()),
|
||||
manager.mk_const(fD.get(), a2.get(), a3.get()));
|
||||
|
||||
TRACE("ackermanize", tout << mk_pp(r.get()) << std::endl;);
|
||||
|
||||
ack.reduce(r);
|
||||
|
||||
TRACE("ackermanize", tout << mk_pp(r.get()) << std::endl;);
|
||||
|
||||
}
|
||||
821
src/dead/test/core_theory.cpp
Normal file
821
src/dead/test/core_theory.cpp
Normal file
|
|
@ -0,0 +1,821 @@
|
|||
/*++
|
||||
Copyright (c) 2006 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
core_theory.cpp
|
||||
|
||||
Abstract:
|
||||
|
||||
Test core theory
|
||||
|
||||
Author:
|
||||
|
||||
Leonardo de Moura (leonardo) 2006-10-20.
|
||||
|
||||
Revision History:
|
||||
|
||||
--*/
|
||||
#include"core_theory.h"
|
||||
#include"theory_diff_logic.h"
|
||||
|
||||
class core_theory_tester {
|
||||
static void tst1() {
|
||||
core_theory t;
|
||||
t.m_params.m_relevancy_lvl = 2;
|
||||
|
||||
enode * n1 = t.mk_const();
|
||||
SASSERT(n1->check_invariant());
|
||||
enode * n2 = t.mk_const();
|
||||
SASSERT(n2->check_invariant());
|
||||
enode * app1 = t.mk_app_core(1, n1, n2);
|
||||
enode * app2 = t.mk_app_core(1, n2, n2);
|
||||
enode * app3 = t.mk_app_core(1, n1, n2);
|
||||
SASSERT(app1 != app2);
|
||||
SASSERT(app1 == app3);
|
||||
|
||||
literal l1 = t.mk_eq(n1, n2);
|
||||
literal l2 = t.mk_eq(n2, n1);
|
||||
literal l4 = t.mk_eq(n2, app1);
|
||||
SASSERT(l1 == l2);
|
||||
SASSERT(l1 != l4);
|
||||
|
||||
SASSERT(n1->get_root() != n2->get_root());
|
||||
|
||||
t.assert_lit(l1);
|
||||
t.assert_lit(l4);
|
||||
t.propagate();
|
||||
|
||||
SASSERT(n1->get_root() == n2->get_root());
|
||||
TRACE("core_theory", t.display(tout););
|
||||
}
|
||||
|
||||
static void tst2() {
|
||||
core_theory t;
|
||||
t.m_params.m_relevancy_lvl = 2;
|
||||
|
||||
enode * n1 = t.mk_const();
|
||||
enode * n2 = t.mk_const();
|
||||
enode * n3 = t.mk_const();
|
||||
|
||||
enode * a1 = t.mk_app_core(1, n1, n2);
|
||||
|
||||
literal l1 = t.mk_eq(n1, n2);
|
||||
t.assert_lit(l1);
|
||||
t.propagate();
|
||||
|
||||
t.push_scope();
|
||||
|
||||
literal l2 = t.mk_eq(n1, n3);
|
||||
t.assign(l2, mk_axiom());
|
||||
|
||||
enode * a2 = t.mk_app_core(1, n1, n1);
|
||||
enode * a3 = t.mk_app_core(1, n1, n3);
|
||||
|
||||
TRACE("core_theory", t.display(tout););
|
||||
|
||||
t.propagate();
|
||||
SASSERT(t.is_equal(a1, a2));
|
||||
SASSERT(!t.is_equal(a1, a3));
|
||||
t.m_sat->mark_as_relevant(l2.var());
|
||||
t.propagate();
|
||||
SASSERT(t.is_equal(a1, a2));
|
||||
SASSERT(t.is_equal(a1, a3));
|
||||
|
||||
t.pop_scope(1);
|
||||
|
||||
t.propagate();
|
||||
SASSERT(to_app(a1)->get_cg() == a1);
|
||||
TRACE("core_theory", t.display(tout););
|
||||
}
|
||||
|
||||
static void tst3() {
|
||||
core_theory t;
|
||||
t.m_params.m_relevancy_lvl = 0;
|
||||
|
||||
enode * n1 = t.mk_const();
|
||||
enode * n2 = t.mk_const();
|
||||
enode * n3 = t.mk_const();
|
||||
|
||||
enode * a1 = t.mk_app_core(1, n1, n2);
|
||||
|
||||
literal l1 = t.mk_eq(n1, n2);
|
||||
t.assert_lit(l1);
|
||||
t.propagate();
|
||||
|
||||
t.push_scope();
|
||||
|
||||
literal l2 = t.mk_eq(n1, n3);
|
||||
t.assign(l2, mk_axiom());
|
||||
|
||||
enode * a2 = t.mk_app_core(1, n1, n1);
|
||||
enode * a3 = t.mk_app_core(1, n1, n3);
|
||||
|
||||
TRACE("core_theory", t.display(tout););
|
||||
|
||||
t.propagate();
|
||||
SASSERT(t.is_equal(a1, a2));
|
||||
SASSERT(t.is_equal(a1, a3));
|
||||
|
||||
t.pop_scope(1);
|
||||
|
||||
t.propagate();
|
||||
SASSERT(to_app(a1)->get_cg() == a1);
|
||||
TRACE("core_theory", t.display(tout););
|
||||
}
|
||||
|
||||
static void tst8() {
|
||||
core_theory t;
|
||||
t.m_params.m_relevancy_lvl = 2;
|
||||
|
||||
enode * n1 = t.mk_const();
|
||||
enode * n2 = t.mk_const();
|
||||
enode * n3 = t.mk_const();
|
||||
enode * n4 = t.mk_const();
|
||||
enode * n5 = t.mk_const();
|
||||
enode * n6 = t.mk_const();
|
||||
|
||||
t.push_scope();
|
||||
|
||||
t.assert_lit(~t.mk_eq(n1, n2));
|
||||
t.assert_lit(t.mk_eq(n1, n3));
|
||||
t.assert_lit(t.mk_eq(n2, n4));
|
||||
t.assert_lit(t.mk_eq(n3, n6));
|
||||
t.assert_lit(t.mk_eq(n1, n5));
|
||||
t.propagate();
|
||||
|
||||
SASSERT(!t.inconsistent());
|
||||
|
||||
t.assert_lit(t.mk_eq(n3, n4));
|
||||
TRACE("core_theory", t.display(tout););
|
||||
t.propagate();
|
||||
|
||||
SASSERT(t.inconsistent());
|
||||
|
||||
t.pop_scope(1);
|
||||
}
|
||||
|
||||
static void tst9() {
|
||||
TRACE("core_theory", tout << "tst9\n";);
|
||||
core_theory t;
|
||||
t.m_params.m_relevancy_lvl = 2;
|
||||
|
||||
t.push_scope();
|
||||
enode * n = t.mk_const();
|
||||
unsigned id = n->get_id();
|
||||
t.pop_scope(1);
|
||||
TRACE("core_theory", tout << "after pop\n";);
|
||||
n = t.mk_const();
|
||||
SASSERT(id == n->get_id());
|
||||
TRACE("core_theory", tout << "end of tst9\n";);
|
||||
}
|
||||
|
||||
static void tst10() {
|
||||
TRACE("core_theory", tout << "tst10\n";);
|
||||
core_theory t;
|
||||
t.m_params.m_relevancy_lvl = 2;
|
||||
|
||||
t.push_scope();
|
||||
enode * n = t.mk_const();
|
||||
unsigned id = n->get_id();
|
||||
t.inc_weak_ref(id);
|
||||
t.pop_scope(1);
|
||||
TRACE("core_theory", tout << "after pop\n";);
|
||||
n = t.mk_const();
|
||||
SASSERT(id + 1 == n->get_id());
|
||||
t.dec_weak_ref(id);
|
||||
n = t.mk_const();
|
||||
SASSERT(id = n->get_id());
|
||||
TRACE("core_theory", tout << "end of tst10\n";);
|
||||
}
|
||||
|
||||
static void tst11() {
|
||||
core_theory t;
|
||||
t.m_params.m_relevancy_lvl = 2;
|
||||
|
||||
enode * n1 = t.mk_const();
|
||||
enode * n2 = t.mk_const();
|
||||
t.add_eq(n1, n2, proto_eq_proof::mk_axiom());
|
||||
enode * f1 = t.mk_app_core(1, n1);
|
||||
enode * f2 = t.mk_app_core(1, n2);
|
||||
t.propagate();
|
||||
SASSERT(t.is_equal(f1, f2));
|
||||
t.push_scope();
|
||||
literal l1 = t.mk_lit();
|
||||
literal l2 = t.mk_eq(f1, f2);
|
||||
t.mk_main_clause(l1, l2);
|
||||
SASSERT(t.get_assignment(l2) == l_true);
|
||||
t.pop_scope(1);
|
||||
SASSERT(t.get_assignment(l2) == l_true);
|
||||
}
|
||||
|
||||
static void tst12() {
|
||||
core_theory t;
|
||||
t.m_params.m_relevancy_lvl = 2;
|
||||
|
||||
enode * n1 = t.mk_const();
|
||||
enode * n2 = t.mk_const();
|
||||
t.add_diseq(n1, n2, proto_diseq_proof::mk_axiom());
|
||||
enode * n3 = t.mk_const();
|
||||
enode * n4 = t.mk_const();
|
||||
t.add_eq(n1, n3, proto_eq_proof::mk_axiom());
|
||||
t.add_eq(n2, n4, proto_eq_proof::mk_axiom());
|
||||
t.propagate();
|
||||
SASSERT(t.is_diseq(n3, n4));
|
||||
t.push_scope();
|
||||
literal l1 = t.mk_lit();
|
||||
literal l2 = t.mk_eq(n3, n4);
|
||||
t.mk_main_clause(l1, l2);
|
||||
SASSERT(t.get_assignment(l2) == l_false);
|
||||
t.pop_scope(1);
|
||||
SASSERT(t.get_assignment(l2) == l_false);
|
||||
}
|
||||
|
||||
static void tst13() {
|
||||
core_theory t;
|
||||
t.m_params.m_relevancy_lvl = 2;
|
||||
|
||||
enode * n1 = t.mk_const();
|
||||
enode * n2 = t.mk_const();
|
||||
enode * n3 = t.mk_const();
|
||||
enode * n4 = t.mk_app_core(1, n1);
|
||||
enode * n5 = t.mk_app_core(1, n4);
|
||||
enode * n6 = t.mk_app_core(1, n3);
|
||||
enode * n7 = t.mk_app_core(1, n6);
|
||||
|
||||
SASSERT(!t.is_relevant(n1));
|
||||
SASSERT(!t.is_relevant(n2));
|
||||
SASSERT(!t.is_relevant(n3));
|
||||
SASSERT(!t.is_relevant(n4));
|
||||
SASSERT(!t.is_relevant(n5));
|
||||
SASSERT(!t.is_relevant(n6));
|
||||
SASSERT(!t.is_relevant(n7));
|
||||
|
||||
t.add_eq(n6, n1, proto_eq_proof::mk_axiom());
|
||||
|
||||
SASSERT(!t.is_relevant(n1));
|
||||
SASSERT(!t.is_relevant(n2));
|
||||
SASSERT(!t.is_relevant(n3));
|
||||
SASSERT(!t.is_relevant(n4));
|
||||
SASSERT(!t.is_relevant(n5));
|
||||
SASSERT(!t.is_relevant(n6));
|
||||
SASSERT(!t.is_relevant(n7));
|
||||
|
||||
t.push_scope();
|
||||
|
||||
t.assert_lit(t.mk_eq(n7,n2));
|
||||
t.propagate();
|
||||
SASSERT(t.is_equal(n7, n2));
|
||||
|
||||
SASSERT(t.is_relevant(n1));
|
||||
SASSERT(t.is_relevant(n2));
|
||||
SASSERT(t.is_relevant(n3));
|
||||
SASSERT(t.is_relevant(n4));
|
||||
SASSERT(!t.is_relevant(n5));
|
||||
SASSERT(t.is_relevant(n6));
|
||||
SASSERT(t.is_relevant(n7));
|
||||
|
||||
t.pop_scope(1);
|
||||
|
||||
SASSERT(!t.is_relevant(n1));
|
||||
SASSERT(!t.is_relevant(n2));
|
||||
SASSERT(!t.is_relevant(n3));
|
||||
SASSERT(!t.is_relevant(n4));
|
||||
SASSERT(!t.is_relevant(n5));
|
||||
SASSERT(!t.is_relevant(n6));
|
||||
SASSERT(!t.is_relevant(n7));
|
||||
}
|
||||
|
||||
static void tst14() {
|
||||
core_theory t;
|
||||
t.m_params.m_relevancy_lvl = 2;
|
||||
|
||||
enode * n1 = t.mk_const();
|
||||
enode * n2 = t.mk_const();
|
||||
enode * n3 = t.mk_const();
|
||||
enode * n4 = t.mk_app_core(1, n1);
|
||||
enode * n5 = t.mk_app_core(1, n4);
|
||||
enode * n6 = t.mk_app_core(1, n3);
|
||||
enode * n7 = t.mk_app_core(1, n6);
|
||||
|
||||
t.assert_lit(t.mk_eq(n1,n2));
|
||||
t.propagate();
|
||||
|
||||
SASSERT(t.is_relevant(n1));
|
||||
SASSERT(t.is_relevant(n2));
|
||||
SASSERT(!t.is_relevant(n3));
|
||||
SASSERT(!t.is_relevant(n4));
|
||||
SASSERT(!t.is_relevant(n5));
|
||||
SASSERT(!t.is_relevant(n6));
|
||||
SASSERT(!t.is_relevant(n7));
|
||||
|
||||
t.push_scope();
|
||||
t.assign_eq(n2, n3, proto_eq_proof::mk_axiom());
|
||||
t.propagate();
|
||||
|
||||
SASSERT(t.is_relevant(n1));
|
||||
SASSERT(t.is_relevant(n2));
|
||||
SASSERT(t.is_relevant(n3));
|
||||
SASSERT(!t.is_relevant(n4));
|
||||
SASSERT(!t.is_relevant(n5));
|
||||
SASSERT(!t.is_relevant(n6));
|
||||
SASSERT(!t.is_relevant(n7));
|
||||
|
||||
t.pop_scope(1);
|
||||
|
||||
SASSERT(t.is_relevant(n1));
|
||||
SASSERT(t.is_relevant(n2));
|
||||
SASSERT(!t.is_relevant(n3));
|
||||
SASSERT(!t.is_relevant(n4));
|
||||
SASSERT(!t.is_relevant(n5));
|
||||
SASSERT(!t.is_relevant(n6));
|
||||
SASSERT(!t.is_relevant(n7));
|
||||
|
||||
t.push_scope();
|
||||
t.assign_eq(n2, n7, proto_eq_proof::mk_axiom());
|
||||
t.propagate();
|
||||
|
||||
SASSERT(t.is_relevant(n1));
|
||||
SASSERT(t.is_relevant(n2));
|
||||
SASSERT(t.is_relevant(n3));
|
||||
SASSERT(!t.is_relevant(n4));
|
||||
SASSERT(!t.is_relevant(n5));
|
||||
SASSERT(t.is_relevant(n6));
|
||||
SASSERT(t.is_relevant(n7));
|
||||
|
||||
t.pop_scope(1);
|
||||
|
||||
SASSERT(t.is_relevant(n1));
|
||||
SASSERT(t.is_relevant(n2));
|
||||
SASSERT(!t.is_relevant(n3));
|
||||
SASSERT(!t.is_relevant(n4));
|
||||
SASSERT(!t.is_relevant(n5));
|
||||
SASSERT(!t.is_relevant(n6));
|
||||
SASSERT(!t.is_relevant(n7));
|
||||
}
|
||||
|
||||
static void tst15() {
|
||||
core_theory t;
|
||||
t.m_params.m_relevancy_lvl = 0;
|
||||
|
||||
literal l1 = t.mk_lit();
|
||||
literal l2 = t.mk_lit();
|
||||
literal l3 = t.mk_lit();
|
||||
literal l4 = t.mk_lit();
|
||||
|
||||
t.push_scope();
|
||||
t.assign(l1, mk_axiom());
|
||||
t.push_scope();
|
||||
|
||||
enode * n1 = t.mk_const();
|
||||
enode * n2 = t.mk_const();
|
||||
enode * a1 = t.mk_app_core(1, n1);
|
||||
enode * a2 = t.mk_app_core(1, n2);
|
||||
enode * n3 = t.mk_const();
|
||||
enode * n4 = t.mk_const();
|
||||
|
||||
literal eq1 = t.mk_eq(a1, n3);
|
||||
t.assign(eq1, mk_axiom());
|
||||
|
||||
t.push_scope();
|
||||
literal eq2 = t.mk_eq(a2, n4);
|
||||
t.assign(eq2, mk_axiom());
|
||||
|
||||
TRACE("core_theory", tout << "eq1: " << eq1 << ", eq2: " << eq2 << "\n";);
|
||||
|
||||
t.mk_transient_clause(~eq2, l3);
|
||||
t.mk_transient_clause(~eq2, l4);
|
||||
t.mk_transient_clause(~eq1, l2);
|
||||
literal_vector lits;
|
||||
lits.push_back(~l4); lits.push_back(~l3); lits.push_back(~l2); lits.push_back(~l1);
|
||||
t.mk_transient_clause(lits);
|
||||
SASSERT(t.inconsistent());
|
||||
#ifdef Z3DEBUG
|
||||
bool r =
|
||||
#endif
|
||||
t.m_sat->resolve_conflict();
|
||||
SASSERT(r);
|
||||
SASSERT(t.m_sat->m_scope_lvl == 2);
|
||||
SASSERT(t.m_sat->m_ref_count[eq1.var()] > 0);
|
||||
SASSERT(t.m_sat->m_ref_count[eq2.var()] > 0);
|
||||
t.pop_scope(2);
|
||||
SASSERT(n1->get_ref_count() > 0);
|
||||
SASSERT(n2->get_ref_count() > 0);
|
||||
SASSERT(a1->get_ref_count() > 0);
|
||||
SASSERT(a2->get_ref_count() > 0);
|
||||
t.push_scope();
|
||||
literal eq3 = t.mk_eq(n1, n2);
|
||||
t.assign(eq3, mk_axiom());
|
||||
t.propagate();
|
||||
TRACE("core_theory", t.display(tout););
|
||||
SASSERT(a1->get_root() == a2->get_root());
|
||||
#ifdef Z3DEBUG
|
||||
t.m_sat->del_learned_clauses();
|
||||
#endif
|
||||
t.pop_scope(1);
|
||||
}
|
||||
|
||||
static void tst16(bool use_relevancy) {
|
||||
core_theory t;
|
||||
t.m_params.m_relevancy_lvl = use_relevancy ? 2 : 0;
|
||||
|
||||
literal l0 = t.mk_lit();
|
||||
literal l1 = t.mk_lit();
|
||||
literal l2 = t.mk_lit();
|
||||
literal l3 = t.mk_lit();
|
||||
literal l4 = t.mk_lit();
|
||||
|
||||
|
||||
enode * n1 = t.mk_const();
|
||||
enode * n2 = t.mk_const();
|
||||
enode * n3 = t.mk_const();
|
||||
enode * n4 = t.mk_app_core(1, n1);
|
||||
|
||||
t.push_scope();
|
||||
t.assign(l0, mk_axiom());
|
||||
|
||||
t.push_scope();
|
||||
t.assign(l1, mk_axiom());
|
||||
|
||||
t.push_scope();
|
||||
enode * n5 = t.mk_app_core(1, n2);
|
||||
enode * n6 = t.mk_const();
|
||||
literal eq1 = t.mk_eq(n5, n6);
|
||||
t.assign(eq1, mk_axiom());
|
||||
t.mk_transient_clause(~l1, l2);
|
||||
t.mk_transient_clause(~eq1, l3);
|
||||
t.mk_transient_clause(~eq1, l4);
|
||||
literal_vector lits;
|
||||
lits.push_back(~l4); lits.push_back(~l3); lits.push_back(~l2);
|
||||
t.mk_transient_clause(lits);
|
||||
SASSERT(t.inconsistent());
|
||||
#ifdef Z3DEBUG
|
||||
bool r =
|
||||
#endif
|
||||
t.m_sat->resolve_conflict();
|
||||
SASSERT(r);
|
||||
t.propagate();
|
||||
SASSERT(t.m_sat->m_scope_lvl == 2);
|
||||
SASSERT(t.m_sat->m_ref_count[eq1.var()] > 0);
|
||||
SASSERT(t.m_sat->get_assignment(eq1) == l_false);
|
||||
|
||||
t.pop_scope(1);
|
||||
SASSERT(t.m_sat->m_scope_lvl == 1);
|
||||
SASSERT(t.m_sat->m_ref_count[eq1.var()] > 0);
|
||||
SASSERT(t.m_sat->get_assignment(eq1) == l_undef);
|
||||
|
||||
t.push_scope();
|
||||
SASSERT(n5->get_ref_count() == 1);
|
||||
t.add_eq(n1, n2, proto_eq_proof::mk_axiom());
|
||||
SASSERT(to_app(n4)->get_cg() == n5);
|
||||
if (use_relevancy) {
|
||||
t.mark_as_relevant(n5);
|
||||
}
|
||||
SASSERT(!use_relevancy || n5->get_ref_count() == 3);
|
||||
SASSERT(use_relevancy || n5->get_ref_count() == 2);
|
||||
SASSERT(n5->get_root() != n4->get_root());
|
||||
SASSERT(!use_relevancy || t.is_relevant(n5));
|
||||
t.propagate();
|
||||
SASSERT(n5->get_root() == n4->get_root());
|
||||
SASSERT(!use_relevancy || n5->get_ref_count() == 4);
|
||||
SASSERT(use_relevancy || n5->get_ref_count() == 3);
|
||||
#ifdef Z3DEBUG
|
||||
t.m_sat->del_learned_clauses();
|
||||
#endif
|
||||
SASSERT(!use_relevancy || n5->get_ref_count() == 3);
|
||||
SASSERT(use_relevancy || n5->get_ref_count() == 2);
|
||||
|
||||
SASSERT(t.m_sat->m_ref_count[eq1.var()] == 0);
|
||||
|
||||
t.pop_scope(1);
|
||||
}
|
||||
|
||||
static void tst17() {
|
||||
theory_idl idl;
|
||||
core_theory t;
|
||||
t.m_params.m_relevancy_lvl = 0;
|
||||
|
||||
t.add_theory(&idl);
|
||||
|
||||
literal l0 = t.mk_lit();
|
||||
literal l1 = t.mk_lit();
|
||||
literal l2 = t.mk_lit();
|
||||
literal l3 = t.mk_lit();
|
||||
literal l4 = t.mk_lit();
|
||||
enode * n1 = t.mk_const();
|
||||
|
||||
t.push_scope();
|
||||
t.assign(l0, mk_axiom());
|
||||
|
||||
t.push_scope();
|
||||
t.assign(l1, mk_axiom());
|
||||
|
||||
t.push_scope();
|
||||
enode * n2 = idl.mk_offset(n1, rational(1));
|
||||
enode * n3 = t.mk_const();
|
||||
literal eq1 = t.mk_eq(n2, n3);
|
||||
t.assign(eq1, mk_axiom());
|
||||
t.mk_transient_clause(~l1, l2);
|
||||
t.mk_transient_clause(~eq1, l3);
|
||||
t.mk_transient_clause(~eq1, l4);
|
||||
literal_vector lits;
|
||||
lits.push_back(~l4); lits.push_back(~l3); lits.push_back(~l2);
|
||||
t.mk_transient_clause(lits);
|
||||
SASSERT(t.inconsistent());
|
||||
#ifdef Z3DEBUG
|
||||
bool r =
|
||||
#endif
|
||||
t.m_sat->resolve_conflict();
|
||||
SASSERT(r);
|
||||
t.propagate();
|
||||
SASSERT(t.m_sat->m_scope_lvl == 2);
|
||||
SASSERT(t.m_sat->m_ref_count[eq1.var()] > 0);
|
||||
SASSERT(t.m_sat->get_assignment(eq1) == l_false);
|
||||
|
||||
t.pop_scope(1);
|
||||
SASSERT(t.m_sat->m_scope_lvl == 1);
|
||||
SASSERT(t.m_sat->m_ref_count[eq1.var()] > 0);
|
||||
SASSERT(t.m_sat->get_assignment(eq1) == l_undef);
|
||||
SASSERT(n2->get_ref_count() == 1);
|
||||
unsigned n2_id = n2->get_id();
|
||||
|
||||
// n2 is still alive
|
||||
#ifdef Z3DEBUG
|
||||
t.m_sat->del_learned_clauses();
|
||||
#endif
|
||||
// n2 is dead
|
||||
SASSERT(t.m_enodes[n2_id] == 0);
|
||||
// n2_id cannot be reused since its weak_counter > 0
|
||||
// SASSERT(t.m_weak_counters[n2_id] > 0);
|
||||
|
||||
enode * n4 = idl.mk_offset(n1, rational(1));
|
||||
SASSERT(n4->get_id() != n2_id);
|
||||
SASSERT(n4->get_id() < static_cast<unsigned>(t.m_next_id));
|
||||
}
|
||||
|
||||
static void tst18() {
|
||||
core_theory t;
|
||||
|
||||
enode * n1 = t.mk_const();
|
||||
enode * n2 = t.mk_const();
|
||||
enode * n3 = t.mk_const();
|
||||
|
||||
enode * a1 = t.mk_app_core(1, n1, n2);
|
||||
|
||||
literal l1 = t.mk_eq(n1, n3);
|
||||
t.assert_lit(l1);
|
||||
t.propagate();
|
||||
|
||||
enode * args[2] = { n3, n2 };
|
||||
|
||||
SASSERT(t.get_enode_eq_to_app(1, 2, args) != 0);
|
||||
SASSERT(a1->get_root() == t.get_enode_eq_to_app(1, 2, args)->get_root());
|
||||
}
|
||||
|
||||
static void tst19() {
|
||||
core_theory t;
|
||||
t.m_params.m_relevancy_lvl = 0;
|
||||
|
||||
enode * n1 = t.mk_const();
|
||||
enode * n2 = t.mk_const();
|
||||
enode * n3 = t.mk_const();
|
||||
|
||||
literal l1 = t.mk_eq(n1, n2);
|
||||
literal l2 = t.mk_eq(n2, n3);
|
||||
literal l3 = t.mk_eq(n1, n3);
|
||||
|
||||
enode * n4 = t.mk_const();
|
||||
enode * n5 = t.mk_const();
|
||||
enode * n6 = t.mk_const();
|
||||
enode * n7 = t.mk_const();
|
||||
|
||||
literal l4 = t.mk_eq(n4, n5);
|
||||
literal l5 = t.mk_eq(n6, n7);
|
||||
literal l6 = t.mk_eq(n5, n7);
|
||||
literal l7 = t.mk_eq(n4, n6);
|
||||
|
||||
t.mk_main_clause(l3, l7);
|
||||
|
||||
t.push_scope();
|
||||
t.assign(l1, mk_axiom());
|
||||
t.assign(~l2, mk_axiom());
|
||||
t.assign(l4, mk_axiom());
|
||||
t.assign(l5, mk_axiom());
|
||||
t.assign(~l6, mk_axiom());
|
||||
t.propagate();
|
||||
SASSERT(t.inconsistent());
|
||||
t.m_sat->resolve_conflict();
|
||||
}
|
||||
|
||||
static void tst20() {
|
||||
theory_idl idl;
|
||||
core_theory t;
|
||||
t.m_params.m_relevancy_lvl = 0;
|
||||
|
||||
t.add_theory(&idl);
|
||||
|
||||
enode * n1 = t.mk_const();
|
||||
enode * n2 = idl.mk_offset(n1, rational(1));
|
||||
enode * n3 = idl.mk_offset(n2, rational(1));
|
||||
enode * n4 = idl.mk_offset(n1, rational(2));
|
||||
SASSERT(n4 == n3);
|
||||
|
||||
enode * r1 = idl.mk_num(rational(1));
|
||||
enode * r2 = idl.mk_offset(r1, rational(1));
|
||||
enode * r3 = idl.mk_num(rational(2));
|
||||
SASSERT(r2 == r3);
|
||||
}
|
||||
|
||||
static void tst21() {
|
||||
enable_debug("add_eq");
|
||||
enable_debug("core_invariant");
|
||||
theory_idl idl;
|
||||
core_theory t;
|
||||
t.m_params.m_relevancy_lvl = 0;
|
||||
t.add_theory(&idl);
|
||||
theory_id idl_id = idl.get_id();
|
||||
|
||||
enode * n1 = t.mk_const();
|
||||
enode * n2 = t.mk_const();
|
||||
enode * n3 = t.mk_const();
|
||||
enode * n4 = t.mk_const();
|
||||
enode * n5 = t.mk_const();
|
||||
literal l1 = t.mk_eq(n1, n2);
|
||||
literal l2 = t.mk_eq(n1, n3);
|
||||
literal l3 = t.mk_eq(n4, n5);
|
||||
literal l4 = t.mk_eq(n4, n3);
|
||||
|
||||
t.push_scope();
|
||||
t.assign(l1, mk_axiom());
|
||||
t.propagate();
|
||||
SASSERT(n2->get_root() == n2);
|
||||
t.push_scope();
|
||||
t.assign(l2, mk_axiom());
|
||||
t.propagate();
|
||||
t.push_scope();
|
||||
t.assign(l3, mk_axiom());
|
||||
t.propagate();
|
||||
SASSERT(n5->get_root() == n5);
|
||||
SASSERT(n4->get_root() == n5);
|
||||
t.push_scope();
|
||||
t.assign(l4, mk_axiom());
|
||||
t.propagate();
|
||||
SASSERT(n2->get_root() == n2);
|
||||
enode * o1 = idl.mk_offset(n4, rational(1));
|
||||
SASSERT(n4->get_th_var(idl_id) != null_theory_var);
|
||||
SASSERT(n2->get_th_var(idl_id) == n4->get_th_var(idl_id));
|
||||
t.pop_scope(1);
|
||||
SASSERT(n4->get_th_var(idl_id) != null_theory_var);
|
||||
SASSERT(n5->get_th_var(idl_id) == n4->get_th_var(idl_id));
|
||||
SASSERT(n2->get_th_var(idl_id) == null_theory_var);
|
||||
t.pop_scope(1);
|
||||
SASSERT(n4->get_th_var(idl.get_id()) != null_theory_var);
|
||||
SASSERT(n5->get_th_var(idl_id) == null_theory_var);
|
||||
SASSERT(n2->get_th_var(idl_id) == null_theory_var);
|
||||
}
|
||||
|
||||
static void tst22() {
|
||||
enable_debug("add_eq");
|
||||
enable_debug("core_invariant");
|
||||
theory_idl idl;
|
||||
core_theory t;
|
||||
t.m_params.m_relevancy_lvl = 0;
|
||||
t.add_theory(&idl);
|
||||
theory_id idl_id = idl.get_id();
|
||||
|
||||
enode * n1 = t.mk_const();
|
||||
enode * n2 = t.mk_const();
|
||||
enode * n3 = t.mk_const();
|
||||
enode * n4 = t.mk_const();
|
||||
enode * n5 = t.mk_const();
|
||||
enode * o1 = idl.mk_offset(n2, rational(1));
|
||||
literal l1 = t.mk_eq(n1, n2);
|
||||
literal l2 = t.mk_eq(n1, n3);
|
||||
literal l3 = t.mk_eq(n4, n5);
|
||||
literal l4 = t.mk_eq(n4, n3);
|
||||
|
||||
t.push_scope();
|
||||
t.assign(l1, mk_axiom());
|
||||
t.propagate();
|
||||
SASSERT(n2->get_root() == n2);
|
||||
|
||||
t.push_scope();
|
||||
t.assign(l2, mk_axiom());
|
||||
t.propagate();
|
||||
|
||||
t.push_scope();
|
||||
t.assign(l3, mk_axiom());
|
||||
t.propagate();
|
||||
SASSERT(n5->get_root() == n5);
|
||||
SASSERT(n4->get_root() == n5);
|
||||
|
||||
t.push_scope();
|
||||
t.assign(l4, mk_axiom());
|
||||
t.propagate();
|
||||
SASSERT(n2->get_root() == n2);
|
||||
enode * o2 = idl.mk_offset(n4, rational(1));
|
||||
SASSERT(n4->get_th_var(idl_id) != null_theory_var);
|
||||
SASSERT(n2->get_th_var(idl_id) != null_theory_var);
|
||||
SASSERT(n2->get_th_var(idl_id) != n4->get_th_var(idl_id));
|
||||
|
||||
t.pop_scope(1);
|
||||
SASSERT(n2->get_th_var(idl_id) != null_theory_var);
|
||||
SASSERT(n4->get_th_var(idl_id) != null_theory_var);
|
||||
SASSERT(n4->get_th_var(idl_id) == n5->get_th_var(idl_id));
|
||||
|
||||
t.pop_scope(1);
|
||||
SASSERT(n2->get_th_var(idl_id) != null_theory_var);
|
||||
SASSERT(n4->get_th_var(idl_id) != null_theory_var);
|
||||
SASSERT(n5->get_th_var(idl_id) == null_theory_var);
|
||||
}
|
||||
|
||||
static void tst23() {
|
||||
core_theory t;
|
||||
t.m_params.m_relevancy_lvl = 0;
|
||||
enable_trace("th_diseq_prop_bug");
|
||||
enable_trace("add_eq");
|
||||
|
||||
enode * n1 = t.mk_const();
|
||||
enode * n2 = t.mk_true_term();
|
||||
enode * d[2] = {n1, n2};
|
||||
t.assert_distinct_class(2, d);
|
||||
enode * n3 = t.mk_const();
|
||||
enode * n4 = t.mk_const();
|
||||
|
||||
literal l1 = t.mk_eq(n3, n4);
|
||||
literal l2 = t.mk_eq(n4, n1);
|
||||
literal l3 = t.mk_eq(n3, n2);
|
||||
t.push_scope();
|
||||
t.assign(l1, mk_axiom());
|
||||
t.propagate();
|
||||
SASSERT(n3->get_root() == n4->get_root());
|
||||
t.push_scope();
|
||||
t.assign(l2, mk_axiom());
|
||||
t.propagate();
|
||||
SASSERT(n3->get_root() == n1->get_root());
|
||||
SASSERT(t.is_diseq(n3, n2));
|
||||
SASSERT(t.get_assignment(l3) == l_false);
|
||||
SASSERT(t.m_sat->m_explanation[l3.var()].kind() == EXPL_EXT);
|
||||
literal_vector antecedents;
|
||||
t.get_antecedents(~l3, t.m_sat->m_explanation[l3.var()].obj(), antecedents);
|
||||
}
|
||||
|
||||
public:
|
||||
static void run_tests() {
|
||||
tst1();
|
||||
tst2();
|
||||
tst3();
|
||||
tst8();
|
||||
tst9();
|
||||
tst10();
|
||||
tst11();
|
||||
tst12();
|
||||
tst13();
|
||||
tst14();
|
||||
tst15();
|
||||
tst16(false);
|
||||
tst16(true);
|
||||
tst17();
|
||||
tst18();
|
||||
tst19();
|
||||
tst20();
|
||||
tst21();
|
||||
tst22();
|
||||
tst23();
|
||||
}
|
||||
};
|
||||
|
||||
struct foo {
|
||||
bool_var m_var; // boolean variable associated with the equation
|
||||
enode * m_lhs;
|
||||
enode * m_rhs;
|
||||
};
|
||||
|
||||
struct bar {
|
||||
bool m_v1:1;
|
||||
bool m_v2:1;
|
||||
bool m_v3:1;
|
||||
bool m_v4:1;
|
||||
bool m_v5:1;
|
||||
bool m_v6:1;
|
||||
bool m_v7:1;
|
||||
bool m_v8:1;
|
||||
};
|
||||
|
||||
struct bar2 {
|
||||
bool m_v1:1;
|
||||
bool m_v2:1;
|
||||
unsigned m_val:30;
|
||||
};
|
||||
|
||||
void tst_core_theory() {
|
||||
TRACE("core_theory", tout << "sizeof(equation): " << sizeof(equation) << "\n";);
|
||||
TRACE("core_theory", tout << "sizeof(foo): " << sizeof(foo) << "\n";);
|
||||
TRACE("core_theory", tout << "sizeof(bar): " << sizeof(bar) << "\n";);
|
||||
TRACE("core_theory", tout << "sizeof(bar2): " << sizeof(bar2) << "\n";);
|
||||
TRACE("core_theory", tout << "sizeof(theory_var_list): " << sizeof(theory_var_list) << "\n";);
|
||||
TRACE("core_theory", tout << "sizeof(enode): " << sizeof(enode) << "\n";);
|
||||
enable_debug("cg_bug");
|
||||
core_theory_tester::run_tests();
|
||||
}
|
||||
|
||||
75
src/dead/test/dimacs.cpp
Normal file
75
src/dead/test/dimacs.cpp
Normal file
|
|
@ -0,0 +1,75 @@
|
|||
/*++
|
||||
Copyright (c) 2006 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
tst_dimacs.cpp
|
||||
|
||||
Abstract:
|
||||
|
||||
Test dimacs parser
|
||||
|
||||
Author:
|
||||
|
||||
Leonardo de Moura (leonardo) 2006-10-02.
|
||||
|
||||
Revision History:
|
||||
|
||||
--*/
|
||||
|
||||
#include <iostream>
|
||||
#include <fstream>
|
||||
#ifdef _WINDOWS
|
||||
#include <windows.h>
|
||||
#include <strsafe.h>
|
||||
#endif
|
||||
#include"trace.h"
|
||||
#include"dimacs_parser.h"
|
||||
|
||||
class dummy_sat {
|
||||
unsigned m_num_vars;
|
||||
public:
|
||||
dummy_sat():m_num_vars(0) {}
|
||||
unsigned get_num_vars() {
|
||||
return m_num_vars;
|
||||
}
|
||||
void mk_var() {
|
||||
TRACE("dimacs", tout << "making variable: p" << m_num_vars << "\n";);
|
||||
m_num_vars++;
|
||||
}
|
||||
void mk_clause(literal_vector & lits) {
|
||||
TRACE("dimacs", tout << "making clause: " << lits << "\n";);
|
||||
}
|
||||
};
|
||||
|
||||
static void tst1()
|
||||
{
|
||||
#ifdef _WINDOWS
|
||||
dummy_sat solver;
|
||||
const char * base = ".";
|
||||
std::string pattern(base);
|
||||
pattern += "\\*.cnf";
|
||||
|
||||
char buffer[MAX_PATH];
|
||||
|
||||
WIN32_FIND_DATAA data;
|
||||
HANDLE h = FindFirstFileA(pattern.c_str(),&data);
|
||||
|
||||
while (h != INVALID_HANDLE_VALUE) {
|
||||
StringCchPrintfA(buffer, ARRAYSIZE(buffer), "%s\\%s", base, data.cFileName);
|
||||
|
||||
TRACE("dimacs", tout << "Parsing: " << buffer << "\n";);
|
||||
|
||||
std::ifstream s(buffer);
|
||||
|
||||
parse_dimacs(s, solver);
|
||||
|
||||
if (!FindNextFileA(h,&data))
|
||||
break;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
void tst_dimacs() {
|
||||
tst1();
|
||||
}
|
||||
296
src/dead/test/distinct.cpp
Normal file
296
src/dead/test/distinct.cpp
Normal file
|
|
@ -0,0 +1,296 @@
|
|||
/*++
|
||||
Copyright (c) 2006 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
distinct.cpp
|
||||
|
||||
Abstract:
|
||||
|
||||
<abstract>
|
||||
|
||||
Author:
|
||||
|
||||
Leonardo de Moura (leonardo) 2006-11-03.
|
||||
|
||||
Revision History:
|
||||
|
||||
--*/
|
||||
#include"core_theory.h"
|
||||
|
||||
class distinct_tester {
|
||||
static void tst1() {
|
||||
core_theory t;
|
||||
t.m_params.m_relevancy_lvl = 0;
|
||||
|
||||
enode * n1 = t.mk_const();
|
||||
enode * n2 = t.mk_const();
|
||||
enode * n3 = t.mk_const();
|
||||
enode * d[3] = {n1, n2, n3};
|
||||
|
||||
enode * n4 = t.mk_const();
|
||||
enode * n5 = t.mk_const();
|
||||
enode * n6 = t.mk_const();
|
||||
|
||||
t.assert_distinct_class(3, d);
|
||||
TRACE("distinct", t.display(tout););
|
||||
t.propagate();
|
||||
|
||||
t.push();
|
||||
|
||||
t.assert_lit(t.mk_eq(n1, n2));
|
||||
t.propagate();
|
||||
SASSERT(t.inconsistent());
|
||||
|
||||
t.pop(1);
|
||||
SASSERT(!t.inconsistent());
|
||||
TRACE("distinct", t.display(tout););
|
||||
|
||||
t.push_scope();
|
||||
|
||||
t.assign(t.mk_eq(n1, n4), mk_axiom());
|
||||
t.assign(t.mk_eq(n2, n5), mk_axiom());
|
||||
t.assign(t.mk_eq(n2, n6), mk_axiom());
|
||||
t.propagate();
|
||||
SASSERT(!t.inconsistent());
|
||||
|
||||
t.assign(t.mk_eq(n4,n5), mk_axiom());
|
||||
t.propagate();
|
||||
TRACE("distinct", t.display(tout););
|
||||
SASSERT(t.inconsistent());
|
||||
}
|
||||
|
||||
static void tst2() {
|
||||
core_theory t;
|
||||
t.m_params.m_relevancy_lvl = 0;
|
||||
|
||||
enode * n1 = t.mk_const();
|
||||
enode * n2 = t.mk_const();
|
||||
enode * n3 = t.mk_const();
|
||||
|
||||
t.assert_lit(t.mk_eq(n1,n3));
|
||||
t.propagate();
|
||||
|
||||
enode * d[3] = {n1, n2, n3};
|
||||
|
||||
t.assert_distinct_class(3, d);
|
||||
SASSERT(t.inconsistent());
|
||||
}
|
||||
|
||||
static void tst3() {
|
||||
core_theory t;
|
||||
t.m_params.m_relevancy_lvl = 0;
|
||||
|
||||
enode * n1 = t.mk_const();
|
||||
enode * n2 = t.mk_const();
|
||||
enode * n3 = t.mk_const();
|
||||
|
||||
t.assert_lit(t.mk_eq(n1,n3));
|
||||
|
||||
enode * d[3] = {n1, n2, n3};
|
||||
|
||||
t.assert_distinct_class(3, d);
|
||||
|
||||
t.propagate();
|
||||
SASSERT(t.inconsistent());
|
||||
}
|
||||
|
||||
static void tst4() {
|
||||
#ifdef ENABLE_DISTINCT_CLASSES_SUPPORT
|
||||
core_theory t;
|
||||
t.m_params.m_relevancy_lvl = 0;
|
||||
|
||||
t.push();
|
||||
|
||||
enode * n1 = t.mk_const();
|
||||
enode * n2 = t.mk_const();
|
||||
enode * n3 = t.mk_const();
|
||||
|
||||
enode * d1[3] = {n1, n2, n3};
|
||||
|
||||
t.assert_distinct_class(3, d1);
|
||||
|
||||
SASSERT(n1->get_distinct_classes() == 1);
|
||||
SASSERT(n2->get_distinct_classes() == 1);
|
||||
SASSERT(n3->get_distinct_classes() == 1);
|
||||
|
||||
enode * n4 = t.mk_const();
|
||||
enode * n5 = t.mk_const();
|
||||
enode * n6 = t.mk_const();
|
||||
|
||||
enode * d2[3] = {n4, n5, n6};
|
||||
|
||||
t.assert_distinct_class(3, d2);
|
||||
|
||||
SASSERT(n4->get_distinct_classes() == 2);
|
||||
SASSERT(n5->get_distinct_classes() == 2);
|
||||
SASSERT(n6->get_distinct_classes() == 2);
|
||||
|
||||
enode * n7 = t.mk_const();
|
||||
enode * n8 = t.mk_const();
|
||||
enode * n9 = t.mk_const();
|
||||
|
||||
enode * d3[3] = {n7, n8, n9};
|
||||
|
||||
t.assert_distinct_class(3, d3);
|
||||
|
||||
SASSERT(n7->get_distinct_classes() == 4);
|
||||
SASSERT(n8->get_distinct_classes() == 4);
|
||||
SASSERT(n9->get_distinct_classes() == 4);
|
||||
|
||||
enode * n10 = t.mk_const();
|
||||
enode * n11 = t.mk_const();
|
||||
enode * n12 = t.mk_const();
|
||||
|
||||
enode * d4[3] = {n10, n11, n12};
|
||||
|
||||
t.assert_distinct_class(3, d4);
|
||||
|
||||
SASSERT(n10->get_distinct_classes() == 8);
|
||||
SASSERT(n11->get_distinct_classes() == 8);
|
||||
SASSERT(n12->get_distinct_classes() == 8);
|
||||
|
||||
t.push_scope();
|
||||
|
||||
t.assign(t.mk_eq(n7, n1), mk_axiom());
|
||||
t.propagate();
|
||||
SASSERT(!t.inconsistent());
|
||||
SASSERT(n1->get_root()->get_distinct_classes() == 5);
|
||||
|
||||
t.push_scope();
|
||||
|
||||
t.assign(t.mk_eq(n11, n5), mk_axiom());
|
||||
t.propagate();
|
||||
SASSERT(!t.inconsistent());
|
||||
SASSERT(n5->get_root()->get_distinct_classes() == 10);
|
||||
|
||||
t.push_scope();
|
||||
t.assign(t.mk_eq(n7, n3), mk_axiom());
|
||||
t.propagate();
|
||||
SASSERT(t.inconsistent());
|
||||
|
||||
t.pop_scope(1);
|
||||
SASSERT(!t.inconsistent());
|
||||
|
||||
t.push_scope();
|
||||
|
||||
t.assign(t.mk_eq(n11, n1), mk_axiom());
|
||||
t.propagate();
|
||||
SASSERT(!t.inconsistent());
|
||||
SASSERT(n1->get_root()->get_distinct_classes() == 15);
|
||||
|
||||
t.pop_scope(1);
|
||||
|
||||
SASSERT(!t.inconsistent());
|
||||
SASSERT(n1->get_root()->get_distinct_classes() == 5);
|
||||
SASSERT(n11->get_root()->get_distinct_classes() == 10);
|
||||
SASSERT(n5->get_root()->get_distinct_classes() == 10);
|
||||
|
||||
t.pop_scope(1);
|
||||
SASSERT(n1->get_root()->get_distinct_classes() == 5);
|
||||
SASSERT(n7->get_root()->get_distinct_classes() == 5);
|
||||
SASSERT(n11->get_root()->get_distinct_classes() == 8);
|
||||
SASSERT(n5->get_root()->get_distinct_classes() == 2);
|
||||
|
||||
t.pop_scope(1);
|
||||
SASSERT(n1->get_root()->get_distinct_classes() == 1);
|
||||
SASSERT(n7->get_root()->get_distinct_classes() == 4);
|
||||
SASSERT(n11->get_root()->get_distinct_classes() == 8);
|
||||
SASSERT(n5->get_root()->get_distinct_classes() == 2);
|
||||
|
||||
SASSERT(t.m_num_distinct_classes == 4);
|
||||
|
||||
t.pop(1);
|
||||
|
||||
SASSERT(t.m_num_distinct_classes == 0);
|
||||
#endif
|
||||
}
|
||||
|
||||
static void tst5() {
|
||||
#ifdef ENABLE_DISTINCT_CLASSES_SUPPORT
|
||||
core_theory t;
|
||||
t.m_params.m_relevancy_lvl = 0;
|
||||
|
||||
t.push();
|
||||
|
||||
enode * n1;
|
||||
enode * n2;
|
||||
enode * n3;
|
||||
|
||||
for (unsigned i = 0; i < 40; i++) {
|
||||
n1 = t.mk_const();
|
||||
n2 = t.mk_const();
|
||||
n3 = t.mk_const();
|
||||
|
||||
enode * d1[3] = {n1, n2, n3};
|
||||
|
||||
t.assert_distinct_class(3, d1);
|
||||
}
|
||||
|
||||
SASSERT(t.m_num_distinct_classes == 32);
|
||||
SASSERT(n1->get_root()->get_distinct_classes() == 0);
|
||||
|
||||
t.push_scope();
|
||||
t.assign(t.mk_eq(n1, n3), mk_axiom());
|
||||
t.propagate();
|
||||
|
||||
SASSERT(t.inconsistent());
|
||||
|
||||
t.pop_scope(1);
|
||||
SASSERT(!t.inconsistent());
|
||||
|
||||
t.pop(1);
|
||||
SASSERT(t.m_num_distinct_classes == 0);
|
||||
|
||||
n1 = t.mk_const();
|
||||
n2 = t.mk_const();
|
||||
n3 = t.mk_const();
|
||||
|
||||
enode * d1[3] = {n1, n2, n3};
|
||||
|
||||
t.assert_distinct_class(3, d1);
|
||||
SASSERT(n1->get_root()->get_distinct_classes() == 1);
|
||||
#endif
|
||||
}
|
||||
|
||||
static void tst6() {
|
||||
core_theory t;
|
||||
t.m_params.m_relevancy_lvl = 0;
|
||||
|
||||
t.push_scope();
|
||||
|
||||
enode * n1 = t.mk_const();
|
||||
enode * n2 = t.mk_const();
|
||||
enode * n3 = t.mk_const();
|
||||
|
||||
enode * d1[3] = {n1, n2, n3};
|
||||
|
||||
t.assert_distinct_class(3, d1);
|
||||
|
||||
SASSERT(t.m_num_distinct_classes == 0);
|
||||
SASSERT(n1->get_root()->get_distinct_classes() == 0);
|
||||
|
||||
t.assign(t.mk_eq(n1, n3), mk_axiom());
|
||||
t.propagate();
|
||||
|
||||
SASSERT(t.inconsistent());
|
||||
}
|
||||
|
||||
public:
|
||||
|
||||
static void run_tests() {
|
||||
tst1();
|
||||
tst2();
|
||||
tst3();
|
||||
tst4();
|
||||
tst5();
|
||||
tst6();
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
void tst_distinct() {
|
||||
enable_trace("core_theory_conflict");
|
||||
distinct_tester::run_tests();
|
||||
}
|
||||
|
||||
101
src/dead/test/fingerprint.cpp
Normal file
101
src/dead/test/fingerprint.cpp
Normal file
|
|
@ -0,0 +1,101 @@
|
|||
/*++
|
||||
Copyright (c) 2006 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
fingerprint.cpp
|
||||
|
||||
Abstract:
|
||||
|
||||
Test fingerprint support
|
||||
|
||||
Author:
|
||||
|
||||
Leonardo de Moura (leonardo) 2006-10-29.
|
||||
|
||||
Revision History:
|
||||
|
||||
--*/
|
||||
#include"core_theory.h"
|
||||
|
||||
bool add_fingerprint(core_theory & t, void * data, enode * n1) {
|
||||
enode * c[1];
|
||||
c[0] = n1;
|
||||
return t.add_fingerprint(data, 1, c);
|
||||
}
|
||||
|
||||
bool add_fingerprint(core_theory & t, void * data, enode * n1, enode * n2) {
|
||||
enode * c[2];
|
||||
c[0] = n1;
|
||||
c[1] = n2;
|
||||
return t.add_fingerprint(data, 2, c);
|
||||
}
|
||||
|
||||
bool add_fingerprint(core_theory & t, void * data, enode * n1, enode * n2, enode * n3, enode * n4, enode * n5, enode * n6, enode * n7, enode * n8, enode * n9) {
|
||||
enode * c[9];
|
||||
c[0] = n1;
|
||||
c[1] = n2;
|
||||
c[2] = n3;
|
||||
c[3] = n4;
|
||||
c[4] = n5;
|
||||
c[5] = n6;
|
||||
c[6] = n7;
|
||||
c[7] = n8;
|
||||
c[8] = n9;
|
||||
return t.add_fingerprint(data, 9, c);
|
||||
}
|
||||
|
||||
class fingerprint_tester {
|
||||
|
||||
static void tst1() {
|
||||
core_theory t;
|
||||
enode * n1 = t.mk_const();
|
||||
enode * n2 = t.mk_const();
|
||||
enode * n3 = t.mk_const();
|
||||
void * d1 = reinterpret_cast<void *>(1);
|
||||
|
||||
SASSERT(add_fingerprint(t, 0, n1));
|
||||
SASSERT(!add_fingerprint(t, 0, n1));
|
||||
SASSERT(add_fingerprint(t, 0, n2));
|
||||
|
||||
SASSERT(add_fingerprint(t, d1, n1));
|
||||
SASSERT(!add_fingerprint(t, d1, n1));
|
||||
SASSERT(add_fingerprint(t, d1, n2));
|
||||
SASSERT(add_fingerprint(t, d1, n1, n2));
|
||||
SASSERT(add_fingerprint(t, d1, n2, n1));
|
||||
SASSERT(!add_fingerprint(t, d1, n1, n2));
|
||||
SASSERT(!add_fingerprint(t, d1, n2, n1));
|
||||
|
||||
t.push_scope();
|
||||
|
||||
SASSERT(add_fingerprint(t, 0, n3));
|
||||
SASSERT(add_fingerprint(t, d1, n3));
|
||||
SASSERT(add_fingerprint(t, d1, n1, n1, n1, n1, n1, n1, n2, n1, n2));
|
||||
SASSERT(!add_fingerprint(t, d1, n1, n1, n1, n1, n1, n1, n2, n1, n2));
|
||||
SASSERT(add_fingerprint(t, d1, n1, n1, n1, n1, n1, n1, n2, n1, n1));
|
||||
SASSERT(!add_fingerprint(t, d1, n1, n1, n1, n1, n1, n1, n2, n1, n1));
|
||||
|
||||
t.pop_scope(1);
|
||||
|
||||
SASSERT(!add_fingerprint(t, 0, n1));
|
||||
SASSERT(!add_fingerprint(t, 0, n2));
|
||||
SASSERT(!add_fingerprint(t, d1, n1, n2));
|
||||
SASSERT(!add_fingerprint(t, d1, n2, n1));
|
||||
SASSERT(add_fingerprint(t, 0, n3));
|
||||
SASSERT(add_fingerprint(t, d1, n3));
|
||||
SASSERT(add_fingerprint(t, d1, n1, n1, n1, n1, n1, n1, n2, n1, n2));
|
||||
SASSERT(!add_fingerprint(t, d1, n1, n1, n1, n1, n1, n1, n2, n1, n2));
|
||||
SASSERT(add_fingerprint(t, d1, n1, n1, n1, n1, n1, n1, n2, n1, n1));
|
||||
SASSERT(!add_fingerprint(t, d1, n1, n1, n1, n1, n1, n1, n2, n1, n1));
|
||||
}
|
||||
|
||||
public:
|
||||
|
||||
static void run_tests() {
|
||||
tst1();
|
||||
}
|
||||
};
|
||||
|
||||
void tst_fingerprint() {
|
||||
fingerprint_tester::run_tests();
|
||||
}
|
||||
472
src/dead/test/gate.cpp
Normal file
472
src/dead/test/gate.cpp
Normal file
|
|
@ -0,0 +1,472 @@
|
|||
/*++
|
||||
Copyright (c) 2006 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
gate.cpp
|
||||
|
||||
Abstract:
|
||||
|
||||
Test SAT gates
|
||||
|
||||
Author:
|
||||
|
||||
Leonardo de Moura (leonardo) 2006-11-02.
|
||||
|
||||
Revision History:
|
||||
|
||||
--*/
|
||||
#include"sat_def.h"
|
||||
|
||||
class gate_extension : public no_extension {
|
||||
public:
|
||||
bool relevancy_enabled() {
|
||||
return true;
|
||||
}
|
||||
|
||||
bool gates_enabled() {
|
||||
return true;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
class gate_no_rel_extension : public no_extension {
|
||||
public:
|
||||
bool relevancy_enabled() {
|
||||
return false;
|
||||
}
|
||||
|
||||
bool gates_enabled() {
|
||||
return true;
|
||||
}
|
||||
};
|
||||
|
||||
class sat_gate_tester {
|
||||
|
||||
static void tst1() {
|
||||
sat_solver<gate_no_rel_extension> solver;
|
||||
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_var();
|
||||
literal l3 = solver.mk_var();
|
||||
|
||||
SASSERT(solver.mk_or(l1, l2, l3) == solver.mk_or(l3, l1, l2));
|
||||
|
||||
SASSERT(solver.mk_or(l1, l1, l3) == solver.mk_or(l3, l1));
|
||||
|
||||
SASSERT(solver.mk_or(l1, l1, l1) == l1);
|
||||
|
||||
SASSERT(solver.mk_or(l1, false_literal, l1) == l1);
|
||||
|
||||
SASSERT(solver.mk_or(l1, true_literal, l1) == true_literal);
|
||||
|
||||
solver.assert_lit(l1);
|
||||
|
||||
SASSERT(solver.mk_or(l1, l2, l3) == true_literal);
|
||||
|
||||
literal l4 = solver.mk_or(l2, l3);
|
||||
|
||||
SASSERT(l4 != true_literal && l4 != false_literal);
|
||||
|
||||
solver.push();
|
||||
|
||||
solver.assert_lit(l2);
|
||||
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.get_assignment(l4) == l_true);
|
||||
|
||||
solver.pop(1);
|
||||
|
||||
SASSERT(solver.get_assignment(l4) == l_undef);
|
||||
|
||||
solver.push();
|
||||
|
||||
solver.assert_lit(~l2);
|
||||
|
||||
solver.assert_lit(~l3);
|
||||
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.get_assignment(l4) == l_false);
|
||||
|
||||
solver.pop(1);
|
||||
|
||||
SASSERT(solver.get_assignment(l4) == l_undef);
|
||||
|
||||
SASSERT(l4 == ~solver.mk_and(~l2, ~l3));
|
||||
}
|
||||
|
||||
static void tst1a() {
|
||||
sat_solver<gate_extension> solver;
|
||||
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_var();
|
||||
literal l3 = solver.mk_var();
|
||||
|
||||
SASSERT(solver.mk_or(l1, l2, l3) == solver.mk_or(l3, l1, l2));
|
||||
|
||||
SASSERT(solver.mk_or(l1, l1, l3) == solver.mk_or(l3, l1));
|
||||
|
||||
SASSERT(solver.mk_or(l1, l1, l1) == l1);
|
||||
|
||||
SASSERT(solver.mk_or(l1, false_literal, l1) == l1);
|
||||
|
||||
SASSERT(solver.mk_or(l1, true_literal, l1) == true_literal);
|
||||
|
||||
solver.assert_lit(l1);
|
||||
|
||||
SASSERT(solver.mk_or(l1, l2, l3) != true_literal);
|
||||
|
||||
literal l4 = solver.mk_or(l2, l3);
|
||||
|
||||
SASSERT(l4 != true_literal && l4 != false_literal);
|
||||
|
||||
solver.push();
|
||||
|
||||
solver.assert_lit(l2);
|
||||
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.get_assignment(l4) == l_true);
|
||||
|
||||
solver.pop(1);
|
||||
|
||||
SASSERT(solver.get_assignment(l4) == l_undef);
|
||||
|
||||
solver.push();
|
||||
|
||||
solver.assert_lit(~l2);
|
||||
|
||||
solver.assert_lit(~l3);
|
||||
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.get_assignment(l4) == l_false);
|
||||
|
||||
solver.pop(1);
|
||||
|
||||
SASSERT(solver.get_assignment(l4) == l_undef);
|
||||
|
||||
SASSERT(l4 == ~solver.mk_and(~l2, ~l3));
|
||||
}
|
||||
|
||||
static void tst2() {
|
||||
sat_solver<gate_extension> solver;
|
||||
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_var();
|
||||
literal l3 = solver.mk_var();
|
||||
|
||||
SASSERT(solver.mk_iff(l1, l2) == solver.mk_iff(l2, l1));
|
||||
|
||||
SASSERT(solver.mk_iff(l1, true_literal) == l1);
|
||||
|
||||
SASSERT(solver.mk_iff(l1, false_literal) == ~l1);
|
||||
|
||||
SASSERT(solver.mk_iff(true_literal, l2) == l2);
|
||||
|
||||
SASSERT(solver.mk_iff(false_literal, l2) == ~l2);
|
||||
|
||||
SASSERT(solver.mk_iff(l1, l1) == true_literal);
|
||||
|
||||
SASSERT(solver.mk_iff(l1, ~l1) == false_literal);
|
||||
}
|
||||
|
||||
static void tst3() {
|
||||
sat_solver<gate_extension> solver;
|
||||
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_var();
|
||||
|
||||
solver.push();
|
||||
|
||||
literal l3 = solver.mk_or(l1, l2);
|
||||
SASSERT(solver.m_ref_count[l3.var()] == 1);
|
||||
|
||||
solver.pop(1);
|
||||
}
|
||||
|
||||
static void tst4() {
|
||||
sat_solver<gate_extension> solver;
|
||||
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_var();
|
||||
|
||||
literal l3 = solver.mk_or(l1, l2);
|
||||
|
||||
solver.reset();
|
||||
|
||||
l1 = solver.mk_var();
|
||||
|
||||
}
|
||||
|
||||
static void tst5() {
|
||||
sat_solver<gate_extension> solver;
|
||||
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_var();
|
||||
literal l3 = solver.mk_var();
|
||||
|
||||
solver.push_scope();
|
||||
|
||||
solver.assign(l1, mk_axiom());
|
||||
|
||||
solver.propagate();
|
||||
|
||||
solver.push_scope();
|
||||
|
||||
literal l4 = solver.mk_or(l1, l2);
|
||||
|
||||
solver.mk_main_clause(l4, l3);
|
||||
|
||||
SASSERT(solver.get_assignment(l4) == l_true);
|
||||
|
||||
solver.pop_scope(1);
|
||||
|
||||
SASSERT(solver.get_assignment(l4) == l_true);
|
||||
}
|
||||
|
||||
static void tst6() {
|
||||
sat_solver<gate_no_rel_extension> solver;
|
||||
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_var();
|
||||
literal l3 = solver.mk_var();
|
||||
literal l4 = solver.mk_var();
|
||||
|
||||
SASSERT(solver.mk_ite(l1, l2, l3) == solver.mk_ite(~l1, l3, l2));
|
||||
|
||||
SASSERT(solver.mk_ite(l1, l2, l2) == l2);
|
||||
|
||||
solver.assert_lit(l1);
|
||||
|
||||
solver.push_scope();
|
||||
|
||||
SASSERT(solver.mk_ite(l1, l2, l3) == l2);
|
||||
|
||||
SASSERT(solver.mk_ite(~l1, l2, l3) == l3);
|
||||
}
|
||||
|
||||
static void tst6a() {
|
||||
sat_solver<gate_extension> solver;
|
||||
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_var();
|
||||
literal l3 = solver.mk_var();
|
||||
literal l4 = solver.mk_var();
|
||||
|
||||
SASSERT(solver.mk_ite(l1, l2, l3) == solver.mk_ite(~l1, l3, l2));
|
||||
|
||||
SASSERT(solver.mk_ite(l1, l2, l2) == l2);
|
||||
|
||||
solver.assert_lit(l1);
|
||||
|
||||
solver.push_scope();
|
||||
|
||||
SASSERT(solver.mk_ite(l1, l2, l3) != l2);
|
||||
|
||||
SASSERT(solver.mk_ite(~l1, l2, l3) != l3);
|
||||
}
|
||||
|
||||
static void tst7() {
|
||||
sat_solver<gate_extension> solver;
|
||||
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_uniq(l1);
|
||||
SASSERT(l1 != l2);
|
||||
|
||||
solver.push();
|
||||
|
||||
solver.assert_lit(l1);
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.get_assignment(l1) == l_true);
|
||||
SASSERT(solver.get_assignment(l2) == l_true);
|
||||
|
||||
solver.pop(1);
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.get_assignment(l1) == l_undef);
|
||||
SASSERT(solver.get_assignment(l2) == l_undef);
|
||||
|
||||
solver.assert_lit(~l1);
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.get_assignment(l1) == l_false);
|
||||
SASSERT(solver.get_assignment(l2) == l_false);
|
||||
}
|
||||
|
||||
static void tst8() {
|
||||
sat_solver<gate_extension> solver;
|
||||
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_uniq(l1);
|
||||
SASSERT(l1 != l2);
|
||||
|
||||
solver.push_scope();
|
||||
|
||||
solver.assert_lit(l1);
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.get_assignment(l1) == l_true);
|
||||
SASSERT(solver.get_assignment(l2) == l_true);
|
||||
|
||||
solver.pop_scope(1);
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.get_assignment(l1) == l_true);
|
||||
SASSERT(solver.get_assignment(l2) == l_true);
|
||||
}
|
||||
|
||||
static void tst9() {
|
||||
sat_solver<gate_extension> s;
|
||||
|
||||
literal l1 = s.mk_var();
|
||||
literal l2 = s.mk_var();
|
||||
literal l3 = s.mk_var();
|
||||
|
||||
s.push_scope();
|
||||
s.assign(l1, mk_axiom());
|
||||
s.push_scope();
|
||||
literal l4 = s.mk_var();
|
||||
literal l5 = s.mk_var();
|
||||
literal l6 = s.mk_or(l4, l5);
|
||||
s.assign(l6, mk_axiom());
|
||||
s.mk_transient_clause(~l6, l3);
|
||||
s.mk_transient_clause(~l6, l2);
|
||||
s.mk_transient_clause(literal_vector(~l3, ~l1, ~l2));
|
||||
SASSERT(s.inconsistent());
|
||||
#ifdef Z3DEBUG
|
||||
bool r =
|
||||
#endif
|
||||
s.resolve_conflict();
|
||||
SASSERT(r);
|
||||
SASSERT(s.m_scope_lvl == 1);
|
||||
SASSERT(s.m_ref_count[l4.var()] > 0);
|
||||
SASSERT(s.m_ref_count[l5.var()] > 0);
|
||||
SASSERT(s.m_ref_count[l6.var()] > 0);
|
||||
s.pop_scope(1);
|
||||
SASSERT(s.get_assignment(l1) == l_undef);
|
||||
SASSERT(s.get_assignment(l4) == l_undef);
|
||||
SASSERT(s.get_assignment(l5) == l_undef);
|
||||
SASSERT(s.get_assignment(l6) == l_undef);
|
||||
SASSERT(s.m_ref_count[l4.var()] > 0);
|
||||
SASSERT(s.m_ref_count[l5.var()] > 0);
|
||||
SASSERT(s.m_ref_count[l6.var()] > 0);
|
||||
s.push_scope();
|
||||
s.assign(~l4, mk_axiom());
|
||||
s.propagate();
|
||||
#ifdef Z3DEBUG
|
||||
s.del_learned_clauses();
|
||||
#endif
|
||||
s.pop_scope(1);
|
||||
}
|
||||
|
||||
static void tst10() {
|
||||
sat_solver<gate_extension> s;
|
||||
|
||||
literal l1 = s.mk_var();
|
||||
literal l2 = s.mk_var();
|
||||
literal l3 = s.mk_var();
|
||||
|
||||
s.push_scope();
|
||||
s.assign(l1, mk_axiom());
|
||||
s.push_scope();
|
||||
literal l4 = s.mk_var();
|
||||
literal l5 = s.mk_var();
|
||||
literal l6 = s.mk_iff(l4, l5);
|
||||
literal l7 = s.mk_var();
|
||||
literal l8 = s.mk_or(l6, l7);
|
||||
s.assign(l8, mk_axiom());
|
||||
s.mk_transient_clause(~l8, l3);
|
||||
s.mk_transient_clause(~l8, l2);
|
||||
s.mk_transient_clause(literal_vector(~l3, ~l1, ~l2));
|
||||
SASSERT(s.inconsistent());
|
||||
#ifdef Z3DEBUG
|
||||
bool r =
|
||||
#endif
|
||||
s.resolve_conflict();
|
||||
SASSERT(r);
|
||||
SASSERT(s.m_scope_lvl == 1);
|
||||
s.pop_scope(1);
|
||||
SASSERT(s.m_ref_count[l4.var()] > 0);
|
||||
SASSERT(s.m_ref_count[l5.var()] > 0);
|
||||
SASSERT(s.m_ref_count[l6.var()] > 0);
|
||||
SASSERT(s.m_ref_count[l7.var()] > 0);
|
||||
SASSERT(s.m_ref_count[l8.var()] > 0);
|
||||
s.push_scope();
|
||||
s.assign(~l1, mk_axiom());
|
||||
s.push_scope();
|
||||
s.assign(l5, mk_axiom());
|
||||
s.mk_transient_clause(~l5, ~l4);
|
||||
s.propagate();
|
||||
SASSERT(s.get_assignment(l6) == l_false);
|
||||
SASSERT(s.get_assignment(l8) == l_undef);
|
||||
#ifdef Z3DEBUG
|
||||
s.del_learned_clauses();
|
||||
SASSERT(s.m_ref_count[l7.var()] == 0);
|
||||
SASSERT(s.m_ref_count[l8.var()] == 0);
|
||||
SASSERT(s.m_ref_count[l4.var()] > 0);
|
||||
SASSERT(s.m_ref_count[l5.var()] > 0);
|
||||
SASSERT(s.m_ref_count[l6.var()] > 0);
|
||||
#endif
|
||||
s.mk_transient_clause(l6, l3);
|
||||
s.mk_transient_clause(l6, l2);
|
||||
s.mk_transient_clause(literal_vector(~l3, l1, ~l2));
|
||||
SASSERT(s.inconsistent());
|
||||
#ifdef Z3DEBUG
|
||||
r =
|
||||
#endif
|
||||
s.resolve_conflict();
|
||||
SASSERT(r);
|
||||
}
|
||||
|
||||
static void tst11() {
|
||||
sat_solver<gate_extension> s;
|
||||
|
||||
literal l0 = s.mk_var();
|
||||
literal l1 = s.mk_var();
|
||||
literal l2 = s.mk_var();
|
||||
|
||||
s.push_scope();
|
||||
s.assign(~l1, mk_axiom());
|
||||
s.assign(~l2, mk_axiom());
|
||||
s.push_scope();
|
||||
literal l3 = s.mk_or(l1, l2);
|
||||
SASSERT(s.get_assignment(l3) == l_false);
|
||||
s.mk_main_clause(l0, l1, l3);
|
||||
SASSERT(s.m_ref_count[l3.var()] == 3);
|
||||
s.pop_scope(1);
|
||||
SASSERT(s.m_ref_count[l3.var()] == 2);
|
||||
SASSERT(s.get_assignment(l3) == l_false);
|
||||
s.assert_lit(l1);
|
||||
s.propagate();
|
||||
SASSERT(s.inconsistent());
|
||||
}
|
||||
|
||||
public:
|
||||
static void run_tests() {
|
||||
enable_trace("del_gate");
|
||||
enable_trace("sat_solver");
|
||||
enable_trace("gate");
|
||||
enable_trace("del_learned_clauses");
|
||||
tst1();
|
||||
tst1a();
|
||||
tst2();
|
||||
tst3();
|
||||
tst4();
|
||||
tst5();
|
||||
tst6();
|
||||
tst6a();
|
||||
tst7();
|
||||
tst8();
|
||||
tst9();
|
||||
tst10();
|
||||
tst11();
|
||||
}
|
||||
};
|
||||
|
||||
void tst_gate() {
|
||||
sat_gate_tester::run_tests();
|
||||
}
|
||||
243
src/dead/test/interval_arithmetic.cpp
Normal file
243
src/dead/test/interval_arithmetic.cpp
Normal file
|
|
@ -0,0 +1,243 @@
|
|||
/*++
|
||||
Copyright (c) 2006 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
interval_arithmetic.cpp
|
||||
|
||||
Abstract:
|
||||
|
||||
Test interval arithmetic
|
||||
|
||||
Author:
|
||||
|
||||
Nikolaj Bjorner (nbjorner) 2006-12-05.
|
||||
|
||||
Revision History:
|
||||
|
||||
--*/
|
||||
#include<iostream>
|
||||
#include"interval_arithmetic.h"
|
||||
#include"trace.h"
|
||||
|
||||
|
||||
template<class number, class epsilon>
|
||||
void tst_ext_number() {
|
||||
typedef ext_number<number, epsilon> num;
|
||||
num zero;
|
||||
num one(1);
|
||||
num eps(num::epsilon());
|
||||
num m_eps(num::epsilon().neg());
|
||||
num two(number(2));
|
||||
num half(number(1,2));
|
||||
num inf = num::infinity();
|
||||
num eps1 = num::epsilon();
|
||||
num three(number(3));
|
||||
num three_e = num::plus(three, num::epsilon());
|
||||
SASSERT(zero.get_sign() == num::ZERO);
|
||||
SASSERT(one.get_sign() == num::POSITIVE);
|
||||
SASSERT(m_eps.get_sign() == num::NEGATIVE);
|
||||
SASSERT(inf.get_sign() == num::POSITIVE);
|
||||
SASSERT(zero.is_zero());
|
||||
SASSERT(!one.is_zero());
|
||||
SASSERT(!inf.is_zero());
|
||||
SASSERT(inf.is_infinite());
|
||||
SASSERT(!one.is_infinite());
|
||||
SASSERT(one.is_pos());
|
||||
SASSERT(m_eps.is_neg());
|
||||
SASSERT(one != zero);
|
||||
SASSERT(inf != one);
|
||||
SASSERT(inf != zero);
|
||||
SASSERT(zero == zero);
|
||||
SASSERT(zero < one);
|
||||
SASSERT(eps < two);
|
||||
SASSERT(zero < eps);
|
||||
SASSERT(zero < inf);
|
||||
SASSERT(zero == min(zero, eps));
|
||||
SASSERT(zero == min(zero, inf));
|
||||
SASSERT(eps == max(zero, eps));
|
||||
SASSERT(inf == max(zero, inf));
|
||||
SASSERT(min(zero,eps) == min(eps,zero));
|
||||
SASSERT(num::plus(zero, eps) == eps);
|
||||
SASSERT(num::plus(zero, one) == one);
|
||||
SASSERT(num::plus(zero, inf) == inf);
|
||||
SASSERT(num::plus(inf, inf) == inf);
|
||||
SASSERT(inf.neg() < inf);
|
||||
SASSERT(inf.neg() < zero);
|
||||
SASSERT(num::minus(zero, one) == one.neg());
|
||||
SASSERT(num::minus(zero, eps) == eps.neg());
|
||||
SASSERT(num::minus(zero, inf) == inf.neg());
|
||||
SASSERT(num::minus(zero, inf.neg()) == inf);
|
||||
SASSERT(num::minus(inf, inf.neg()) == inf);
|
||||
|
||||
// sup_mult, inf_mult
|
||||
SASSERT(sup_mult(zero, one) == zero);
|
||||
SASSERT(sup_mult(one, one) == one);
|
||||
SASSERT(sup_mult(one, one.neg()) == one.neg());
|
||||
SASSERT(inf_mult(zero, one) == zero);
|
||||
SASSERT(inf_mult(one, one) == one);
|
||||
SASSERT(inf_mult(one, one.neg()) == one.neg());
|
||||
|
||||
// sup_div, inf_div
|
||||
SASSERT(one < sup_div(three_e, three));
|
||||
SASSERT(inf_div(three, three_e) < one);
|
||||
SASSERT(inf_div(three_e, three) < two);
|
||||
SASSERT(inf_div(three.neg(), three_e.neg()) < one);
|
||||
SASSERT(one < sup_div(three_e.neg(), three.neg()));
|
||||
SASSERT(inf_div(three_e.neg(), three.neg()) < two);
|
||||
|
||||
// sup_power, inf_power
|
||||
SASSERT(sup_power(one,3) == one);
|
||||
SASSERT(sup_power(one,3) > zero);
|
||||
SASSERT(sup_power(num::plus(one, num::epsilon()),3) > one);
|
||||
|
||||
SASSERT(sup_power(one,2) == one);
|
||||
SASSERT(sup_power(one,2) > zero);
|
||||
SASSERT(sup_power(num::plus(one, num::epsilon()),2) > one);
|
||||
|
||||
// sup_root, inf_root
|
||||
SASSERT(sup_root(one,2) >= zero);
|
||||
SASSERT(inf_root(one,2) <= one);
|
||||
SASSERT(sup_root(zero,2) >= zero);
|
||||
SASSERT(inf_root(zero,2) <= zero);
|
||||
|
||||
}
|
||||
|
||||
template<class number, class epsilon>
|
||||
void tst_interval()
|
||||
{
|
||||
typedef interval<number, epsilon> interval;
|
||||
typedef ext_number<number, epsilon> ext_num;
|
||||
ext_num m_inf(ext_num::infinity().neg());
|
||||
ext_num m_three(ext_num(3).neg());
|
||||
ext_num m_three_m_e(ext_num::plus(ext_num(3), ext_num::epsilon()).neg());
|
||||
ext_num m_three_p_e(ext_num::plus(ext_num(3), ext_num::epsilon().neg()).neg());
|
||||
ext_num m_eps(ext_num::epsilon().neg());
|
||||
ext_num zero(0);
|
||||
ext_num eps(ext_num::epsilon());
|
||||
ext_num three(ext_num(3));
|
||||
ext_num three_m_e(ext_num::minus(ext_num(3), ext_num::epsilon()));
|
||||
ext_num three_p_e(ext_num::plus(ext_num(3), ext_num::epsilon()));
|
||||
ext_num inf(ext_num::infinity());
|
||||
ext_num nums[] = { m_inf, m_three_m_e, m_three, m_three_p_e, m_eps, zero, eps, three_m_e, three, three_p_e, inf };
|
||||
|
||||
unsigned n_nums = 11;
|
||||
//
|
||||
// add_lower
|
||||
// add_upper
|
||||
//
|
||||
for (unsigned i = 0; i < n_nums; ++i) {
|
||||
for (unsigned j = i+1; j < n_nums; ++j) {
|
||||
|
||||
for (unsigned k = 0; k < n_nums; ++k) {
|
||||
interval i1(nums[i], nums[j]);
|
||||
bool ok = i1.add_lower(nums[k]);
|
||||
TRACE("interval_arithmetic", tout << "lower: " << ok << " "
|
||||
<< nums[k] << " " << i1 << std::endl;);
|
||||
}
|
||||
|
||||
for (unsigned k = 0; k < n_nums; ++k) {
|
||||
interval i1(nums[i], nums[j]);
|
||||
bool ok = i1.add_upper(nums[k]);
|
||||
TRACE("interval_arithmetic", tout << "upper: " << ok << " "
|
||||
<< nums[k] << " " << i1 << std::endl;);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// +
|
||||
// *
|
||||
// -
|
||||
// quotient
|
||||
//
|
||||
for (unsigned i = 0; i < n_nums; ++i) {
|
||||
for (unsigned j = i+1; j < n_nums; ++j) {
|
||||
interval i1(nums[i],nums[j]);
|
||||
|
||||
interval x = i1.power(0);
|
||||
interval y = i1.power(1);
|
||||
interval z = i1.power(2);
|
||||
interval x1 = i1.power(3);
|
||||
|
||||
for (unsigned k = 0; k < n_nums; ++k) {
|
||||
for (unsigned l = k+1; l < n_nums; ++l) {
|
||||
interval i2(nums[k],nums[l]);
|
||||
interval i3 = i1 + i2;
|
||||
interval i4 = i1 - i2;
|
||||
interval i5 = i1 * i2;
|
||||
TRACE("interval_arithmetic", tout << i1 << " + " << i2 << " = " << i3 << std::endl;);
|
||||
TRACE("interval_arithmetic", tout << i1 << " - " << i2 << " = " << i4 << std::endl;);
|
||||
TRACE("interval_arithmetic", tout << i1 << " * " << i2 << " = " << i5 << std::endl;);
|
||||
SASSERT(i5 == i2 * i1);
|
||||
vector<interval, true> intervals;
|
||||
interval::quotient(i1, i2, intervals);
|
||||
TRACE("interval_arithmetic",
|
||||
tout << i1 << " / " << i2 << " = " ;
|
||||
for (unsigned idx = 0; idx < intervals.size(); ++idx) {
|
||||
tout << intervals[idx] << " ";
|
||||
}
|
||||
tout << std::endl;
|
||||
);
|
||||
|
||||
unsigned changed_bounds;
|
||||
x = i1;
|
||||
y = i2;
|
||||
z = i3;
|
||||
TRACE("interval_arithmetic", tout << "check: " << i1 << "=" << i2 << "*" << i3 << std::endl;);
|
||||
if (interval::check_mult(x, y, z, changed_bounds)) {
|
||||
TRACE("interval_arithmetic", tout << x << "=" << y << "*" << z << std::endl;);
|
||||
SASSERT (!!(changed_bounds & 0x1) == (x.low() != i1.low()));
|
||||
SASSERT (!!(changed_bounds & 0x2) == (x.high() != i1.high()));
|
||||
SASSERT (!!(changed_bounds & 0x4) == (y.low() != i2.low()));
|
||||
SASSERT (!!(changed_bounds & 0x8) == (y.high() != i2.high()));
|
||||
SASSERT (!!(changed_bounds & 0x10) == (z.low() != i3.low()));
|
||||
SASSERT (!!(changed_bounds & 0x20) == (z.high() != i3.high()));
|
||||
}
|
||||
else {
|
||||
TRACE("interval_arithmetic", tout << "unsat" << std::endl;);
|
||||
}
|
||||
|
||||
x = i1;
|
||||
y = i2;
|
||||
if (interval::check_power(x, y, 3, changed_bounds)) {
|
||||
TRACE("interval_arithmetic",
|
||||
tout << "check: " << i1 << "=" << i2 << "^3" << " -> "
|
||||
<< x << " = " << y << "^3" << std::endl;);
|
||||
}
|
||||
else {
|
||||
TRACE("interval_arithmetic", tout << "unsat: " << i1 << "=" << i2 << "^4" << std::endl;);
|
||||
}
|
||||
|
||||
|
||||
x = i1;
|
||||
y = i2;
|
||||
if (interval::check_power(x, y, 4, changed_bounds)) {
|
||||
TRACE("interval_arithmetic",
|
||||
tout << "check: " << i1 << "=" << i2 << "^4" << " -> "
|
||||
<< x << " = " << y << "^4" << std::endl;);
|
||||
}
|
||||
else {
|
||||
TRACE("interval_arithmetic", tout << "unsat: " << i1 << "=" << i2 << "^4" << std::endl;);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// check_mult(i1, i2, i3, change_bounds);
|
||||
|
||||
// check_power(i1, i2, power, changed_bounds);
|
||||
}
|
||||
|
||||
struct eps1 { rational operator()() { return rational(1); } };
|
||||
struct eps0 { inf_rational operator()() { return inf_rational(rational(0),true); } };
|
||||
|
||||
void tst_interval_arithmetic() {
|
||||
TRACE("interval_arithmetic", tout << "starting interval_arithmetic test...\n";);
|
||||
tst_ext_number<rational, eps1>();
|
||||
tst_ext_number<inf_rational, eps0>();
|
||||
tst_interval<rational, eps1>();
|
||||
tst_interval<inf_rational, eps0>();
|
||||
}
|
||||
653
src/dead/test/relevancy.cpp
Normal file
653
src/dead/test/relevancy.cpp
Normal file
|
|
@ -0,0 +1,653 @@
|
|||
/*++
|
||||
Copyright (c) 2006 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
relevancy.cpp
|
||||
|
||||
Abstract:
|
||||
|
||||
Test relevancy propagation.
|
||||
|
||||
Author:
|
||||
|
||||
Leonardo de Moura (leonardo) 2006-11-03.
|
||||
|
||||
Revision History:
|
||||
|
||||
--*/
|
||||
#include"sat_def.h"
|
||||
|
||||
class relevancy_extension : public no_extension {
|
||||
public:
|
||||
bool relevancy_enabled() {
|
||||
return true;
|
||||
}
|
||||
|
||||
bool gates_enabled() {
|
||||
return true;
|
||||
}
|
||||
};
|
||||
|
||||
class sat_relevancy_tester {
|
||||
|
||||
static void tst1() {
|
||||
sat_solver<relevancy_extension> solver;
|
||||
|
||||
literal l1 = solver.mk_var();
|
||||
|
||||
SASSERT(!solver.is_relevant(l1.var()));
|
||||
|
||||
solver.assert_lit(l1);
|
||||
|
||||
SASSERT(solver.is_relevant(l1.var()));
|
||||
}
|
||||
|
||||
static void tst2() {
|
||||
sat_solver<relevancy_extension> solver;
|
||||
|
||||
literal l1 = solver.mk_var();
|
||||
|
||||
solver.push_scope();
|
||||
|
||||
SASSERT(!solver.is_relevant(l1.var()));
|
||||
|
||||
solver.assert_lit(l1);
|
||||
|
||||
SASSERT(solver.is_relevant(l1.var()));
|
||||
|
||||
solver.pop_scope(1);
|
||||
|
||||
SASSERT(solver.is_relevant(l1.var()));
|
||||
}
|
||||
|
||||
static void tst3() {
|
||||
sat_solver<relevancy_extension> solver;
|
||||
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_var();
|
||||
literal l3 = solver.mk_var();
|
||||
|
||||
literal l4 = solver.mk_ite(l1, l2, l3);
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(!solver.is_relevant(l3));
|
||||
SASSERT(!solver.is_relevant(l4));
|
||||
|
||||
solver.mark_as_relevant(l4.var());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(!solver.is_relevant(l3));
|
||||
SASSERT(solver.is_relevant(l4));
|
||||
|
||||
solver.push_scope();
|
||||
|
||||
solver.assign(l1, mk_axiom());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.is_relevant(l1));
|
||||
SASSERT(solver.is_relevant(l2));
|
||||
SASSERT(!solver.is_relevant(l3));
|
||||
SASSERT(solver.is_relevant(l4));
|
||||
|
||||
solver.pop_scope(1);
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(!solver.is_relevant(l3));
|
||||
SASSERT(solver.is_relevant(l4));
|
||||
|
||||
solver.assign(~l1, mk_axiom());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(solver.is_relevant(l3));
|
||||
SASSERT(solver.is_relevant(l4));
|
||||
}
|
||||
|
||||
static void tst4() {
|
||||
sat_solver<relevancy_extension> solver;
|
||||
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_var();
|
||||
literal l3 = solver.mk_var();
|
||||
literal l4 = solver.mk_ite(l1, l2, l3);
|
||||
solver.propagate();
|
||||
|
||||
solver.push_scope();
|
||||
|
||||
solver.assign(l1, mk_axiom());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(!solver.is_relevant(l3));
|
||||
SASSERT(!solver.is_relevant(l4));
|
||||
|
||||
solver.mark_as_relevant(l4.var());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.is_relevant(l1));
|
||||
SASSERT(solver.is_relevant(l2));
|
||||
SASSERT(!solver.is_relevant(l3));
|
||||
SASSERT(solver.is_relevant(l4));
|
||||
|
||||
solver.pop_scope(1);
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(!solver.is_relevant(l3));
|
||||
SASSERT(!solver.is_relevant(l4));
|
||||
|
||||
solver.assign(~l1, mk_axiom());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(!solver.is_relevant(l3));
|
||||
SASSERT(!solver.is_relevant(l4));
|
||||
|
||||
solver.mark_as_relevant(l4.var());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(solver.is_relevant(l3));
|
||||
SASSERT(solver.is_relevant(l4));
|
||||
}
|
||||
|
||||
static void tst5() {
|
||||
sat_solver<relevancy_extension> solver;
|
||||
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_var();
|
||||
literal l3 = solver.mk_var();
|
||||
|
||||
solver.push_scope();
|
||||
|
||||
solver.assign(l1, mk_axiom());
|
||||
solver.propagate();
|
||||
|
||||
literal l4 = solver.mk_ite(l1, l2, l3);
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(!solver.is_relevant(l3));
|
||||
SASSERT(!solver.is_relevant(l4));
|
||||
|
||||
solver.mark_as_relevant(l4.var());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.is_relevant(l1));
|
||||
SASSERT(solver.is_relevant(l2));
|
||||
SASSERT(!solver.is_relevant(l3));
|
||||
SASSERT(solver.is_relevant(l4));
|
||||
}
|
||||
|
||||
static void tst6() {
|
||||
sat_solver<relevancy_extension> solver;
|
||||
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_var();
|
||||
literal l3 = solver.mk_iff(l1, l2);
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(!solver.is_relevant(l3));
|
||||
|
||||
solver.push_scope();
|
||||
|
||||
solver.mark_as_relevant(l3.var());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.is_relevant(l1));
|
||||
SASSERT(solver.is_relevant(l2));
|
||||
SASSERT(solver.is_relevant(l3));
|
||||
|
||||
solver.pop_scope(1);
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(!solver.is_relevant(l3));
|
||||
|
||||
solver.push_scope();
|
||||
|
||||
solver.mark_as_relevant(l2.var());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(solver.is_relevant(l2));
|
||||
SASSERT(!solver.is_relevant(l3));
|
||||
|
||||
solver.pop_scope(1);
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(!solver.is_relevant(l3));
|
||||
}
|
||||
|
||||
static void tst7() {
|
||||
sat_solver<relevancy_extension> solver;
|
||||
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_var();
|
||||
literal l3 = solver.mk_or(l1, l2);
|
||||
|
||||
solver.push_scope();
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(!solver.is_relevant(l3));
|
||||
|
||||
solver.mark_as_relevant(l3.var());
|
||||
solver.assign(l3, mk_axiom());
|
||||
solver.assign(l2, mk_axiom());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(solver.is_relevant(l2));
|
||||
SASSERT(solver.is_relevant(l3));
|
||||
|
||||
solver.assign(l1, mk_axiom());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(solver.is_relevant(l2));
|
||||
SASSERT(solver.is_relevant(l3));
|
||||
|
||||
solver.pop_scope(1);
|
||||
solver.propagate();
|
||||
solver.push_scope();
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(!solver.is_relevant(l3));
|
||||
|
||||
solver.mark_as_relevant(l3.var());
|
||||
solver.assign(l3, mk_axiom());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(solver.is_relevant(l3));
|
||||
|
||||
solver.assign(l1, mk_axiom());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(solver.is_relevant(l3));
|
||||
|
||||
solver.assign(l2, mk_axiom());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(solver.is_relevant(l3));
|
||||
|
||||
solver.pop_scope(1);
|
||||
solver.propagate();
|
||||
solver.push_scope();
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(!solver.is_relevant(l3));
|
||||
|
||||
solver.assign(~l3, mk_axiom());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(!solver.is_relevant(l3));
|
||||
|
||||
solver.mark_as_relevant(l3.var());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.is_relevant(l1));
|
||||
SASSERT(solver.is_relevant(l2));
|
||||
SASSERT(solver.is_relevant(l3));
|
||||
|
||||
solver.pop_scope(1);
|
||||
solver.propagate();
|
||||
solver.push_scope();
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(!solver.is_relevant(l3));
|
||||
|
||||
solver.mark_as_relevant(l3.var());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(solver.is_relevant(l3));
|
||||
|
||||
solver.assign(~l3, mk_axiom());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.is_relevant(l1));
|
||||
SASSERT(solver.is_relevant(l2));
|
||||
SASSERT(solver.is_relevant(l3));
|
||||
}
|
||||
|
||||
static void tst8() {
|
||||
sat_solver<relevancy_extension> solver;
|
||||
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_var();
|
||||
literal l3 = solver.mk_or(l1, l2);
|
||||
|
||||
solver.push_scope();
|
||||
|
||||
solver.mark_as_relevant(l3.var());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(solver.is_relevant(l3));
|
||||
|
||||
solver.assign(l1, mk_axiom());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(solver.is_relevant(l3));
|
||||
|
||||
solver.assign(l2, mk_axiom());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(solver.is_relevant(l3));
|
||||
|
||||
solver.pop_scope(1);
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(!solver.is_relevant(l3));
|
||||
}
|
||||
|
||||
static void tst9() {
|
||||
sat_solver<relevancy_extension> solver;
|
||||
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_var();
|
||||
literal l3 = solver.mk_or(l1, l2);
|
||||
|
||||
solver.mark_as_relevant(l3.var());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(solver.is_relevant(l3));
|
||||
|
||||
solver.assign(l1, mk_axiom());
|
||||
solver.assign(l2, mk_axiom());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.is_relevant(l1) || solver.is_relevant(l2));
|
||||
SASSERT(solver.is_relevant(l1) != solver.is_relevant(l2));
|
||||
SASSERT(solver.is_relevant(l3));
|
||||
}
|
||||
|
||||
static void tst10() {
|
||||
sat_solver<relevancy_extension> solver;
|
||||
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_var();
|
||||
literal l3 = solver.mk_or(l1, l2);
|
||||
|
||||
solver.assign(l1, mk_axiom());
|
||||
solver.assign(l2, mk_axiom());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(!solver.is_relevant(l3));
|
||||
|
||||
solver.mark_as_relevant(l3.var());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.is_relevant(l1) || solver.is_relevant(l2));
|
||||
SASSERT(solver.is_relevant(l1) != solver.is_relevant(l2));
|
||||
SASSERT(solver.is_relevant(l3));
|
||||
}
|
||||
|
||||
static void tst11() {
|
||||
sat_solver<relevancy_extension> solver;
|
||||
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_var();
|
||||
literal l3 = solver.mk_iff(l1, l2);
|
||||
literal l4 = solver.mk_var();
|
||||
literal l5 = solver.mk_or(l3, l4);
|
||||
|
||||
solver.propagate();
|
||||
solver.push_scope();
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(!solver.is_relevant(l3));
|
||||
SASSERT(!solver.is_relevant(l4));
|
||||
SASSERT(!solver.is_relevant(l5));
|
||||
|
||||
solver.assign(l3, mk_axiom());
|
||||
solver.mark_as_relevant(l5.var());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.is_relevant(l1));
|
||||
SASSERT(solver.is_relevant(l2));
|
||||
SASSERT(solver.is_relevant(l3));
|
||||
SASSERT(!solver.is_relevant(l4));
|
||||
SASSERT(solver.is_relevant(l5));
|
||||
|
||||
solver.assign(l4, mk_axiom());
|
||||
solver.propagate();
|
||||
SASSERT(!solver.is_relevant(l4));
|
||||
|
||||
solver.pop_scope(1);
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(!solver.is_relevant(l3));
|
||||
SASSERT(!solver.is_relevant(l4));
|
||||
SASSERT(!solver.is_relevant(l5));
|
||||
|
||||
solver.assign(l4, mk_axiom());
|
||||
solver.mark_as_relevant(l5.var());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(!solver.is_relevant(l3));
|
||||
SASSERT(solver.is_relevant(l4));
|
||||
SASSERT(solver.is_relevant(l5));
|
||||
|
||||
solver.assign(l1, mk_axiom());
|
||||
solver.assign(l2, mk_axiom());
|
||||
solver.assign(l3, mk_axiom());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(!solver.is_relevant(l3));
|
||||
SASSERT(solver.is_relevant(l4));
|
||||
SASSERT(solver.is_relevant(l5));
|
||||
}
|
||||
|
||||
static void tst12(clause_kind k) {
|
||||
sat_solver<relevancy_extension> solver;
|
||||
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_var();
|
||||
|
||||
solver.mk_aux_clause(l1, l2, k);
|
||||
|
||||
solver.push_scope();
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
|
||||
solver.assign(l1, mk_axiom());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
|
||||
solver.assign(l2, mk_axiom());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
|
||||
solver.pop_scope(1);
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
}
|
||||
|
||||
static void tst13(clause_kind k) {
|
||||
sat_solver<relevancy_extension> solver;
|
||||
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_var();
|
||||
|
||||
solver.mk_aux_clause(l1, l2, k);
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
|
||||
solver.assign(l1, mk_axiom());
|
||||
solver.assign(l2, mk_axiom());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
}
|
||||
|
||||
static void tst14() {
|
||||
sat_solver<relevancy_extension> solver;
|
||||
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_var();
|
||||
|
||||
solver.push_scope();
|
||||
|
||||
solver.assign(l1, mk_axiom());
|
||||
|
||||
solver.mk_aux_clause(l1, l2, CLS_MAIN);
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.is_relevant(l1));
|
||||
}
|
||||
|
||||
static void tst15() {
|
||||
sat_solver<relevancy_extension> solver;
|
||||
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_var();
|
||||
|
||||
solver.push_scope();
|
||||
|
||||
solver.assign(l1, mk_axiom());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
|
||||
solver.push_scope();
|
||||
|
||||
solver.mk_aux_clause(l1, l2, CLS_MAIN);
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.is_relevant(l1));
|
||||
|
||||
solver.pop_scope(1);
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.is_relevant(l1));
|
||||
}
|
||||
|
||||
static void tst16() {
|
||||
sat_solver<relevancy_extension> solver;
|
||||
|
||||
literal l1 = solver.mk_var();
|
||||
|
||||
solver.push_scope();
|
||||
solver.assert_lit(l1);
|
||||
solver.propagate();
|
||||
SASSERT(solver.is_relevant(l1));
|
||||
SASSERT(solver.get_assignment(l1) == l_true);
|
||||
solver.assert_lit(l1);
|
||||
solver.pop_scope(1);
|
||||
SASSERT(solver.get_assignment(l1) == l_true);
|
||||
SASSERT(solver.is_relevant(l1));
|
||||
}
|
||||
|
||||
static void tst17() {
|
||||
sat_solver<relevancy_extension> solver;
|
||||
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_var();
|
||||
solver.assert_nonrelevant_lit(l1);
|
||||
solver.mk_aux_clause(l1, l2, CLS_MAIN);
|
||||
solver.check();
|
||||
SASSERT(solver.get_assignment(l1) == l_true || solver.get_assignment(l2) == l_true);
|
||||
SASSERT(solver.is_relevant(l1) || solver.is_relevant(l2));
|
||||
}
|
||||
|
||||
static void tst18() {
|
||||
sat_solver<relevancy_extension> solver;
|
||||
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_var();
|
||||
solver.assert_nonrelevant_lit(l1);
|
||||
literal l3 = solver.mk_or(l1, l2);
|
||||
SASSERT(l3 != true_literal);
|
||||
solver.assert_lit(l3);
|
||||
lbool r = solver.check();
|
||||
SASSERT(r == l_true);
|
||||
SASSERT(solver.is_relevant(l3));
|
||||
SASSERT(solver.is_relevant(l1));
|
||||
}
|
||||
|
||||
public:
|
||||
|
||||
static void run_tests() {
|
||||
tst1();
|
||||
tst2();
|
||||
tst3();
|
||||
tst4();
|
||||
tst5();
|
||||
tst6();
|
||||
tst7();
|
||||
tst8();
|
||||
tst9();
|
||||
tst10();
|
||||
tst11();
|
||||
tst12(CLS_MAIN);
|
||||
tst12(CLS_TRANSIENT);
|
||||
tst13(CLS_AUXILIARY);
|
||||
tst13(CLS_EXT_LEMMA);
|
||||
tst13(CLS_EXTERNAL);
|
||||
tst14();
|
||||
tst15();
|
||||
tst16();
|
||||
tst17();
|
||||
tst18();
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
void tst_relevancy() {
|
||||
sat_relevancy_tester::run_tests();
|
||||
}
|
||||
389
src/dead/test/sat.cpp
Normal file
389
src/dead/test/sat.cpp
Normal file
|
|
@ -0,0 +1,389 @@
|
|||
/*++
|
||||
Copyright (c) 2006 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
tst_sat.cpp
|
||||
|
||||
Abstract:
|
||||
|
||||
Test SAT solver
|
||||
|
||||
Author:
|
||||
|
||||
Leonardo de Moura (leonardo) 2006-10-05.
|
||||
|
||||
Revision History:
|
||||
|
||||
--*/
|
||||
|
||||
#include"sat_def.h"
|
||||
|
||||
class sat_tester {
|
||||
|
||||
static void tst1() {
|
||||
sat_solver<no_extension> solver;
|
||||
solver.push_user_scope();
|
||||
solver.push_scope();
|
||||
literal l1 = solver.mk_var();
|
||||
SASSERT(solver.m_ref_count[l1.var()] == 1);
|
||||
solver.assert_lit(l1);
|
||||
SASSERT(solver.m_ref_count[l1.var()] == 2);
|
||||
SASSERT(solver.m_weak_ref_count[l1.var()] == 1);
|
||||
SASSERT(solver.get_assignment(l1) == l_true);
|
||||
SASSERT(solver.m_level[l1.var()] == 1);
|
||||
literal l2 = solver.mk_var();
|
||||
SASSERT(solver.m_ref_count[l2.var()] == 1);
|
||||
SASSERT(solver.get_assignment(l2) == l_undef);
|
||||
SASSERT(solver.m_level.size() == 3);
|
||||
SASSERT(solver.m_free_var_indices.size() == 0);
|
||||
solver.pop_scope(1);
|
||||
SASSERT(solver.m_free_var_indices.size() == 2);
|
||||
SASSERT(solver.m_ref_count[l1.var()] == 0);
|
||||
}
|
||||
|
||||
template<typename Ext>
|
||||
static void tst2() {
|
||||
sat_solver<Ext> solver;
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_var();
|
||||
literal l3 = solver.mk_var();
|
||||
literal l4 = solver.mk_var();
|
||||
solver.mk_aux_clause(~l1, ~l2, l3, CLS_MAIN);
|
||||
solver.mk_aux_clause(~l3, ~l4, CLS_MAIN);
|
||||
solver.push_scope();
|
||||
solver.assign(l1, mk_axiom());
|
||||
solver.assign(l2, mk_axiom());
|
||||
SASSERT(solver.get_assignment(l3) == l_undef);
|
||||
SASSERT(solver.get_assignment(l4) == l_undef);
|
||||
solver.propagate();
|
||||
SASSERT(solver.get_assignment(l3) == l_true);
|
||||
SASSERT(solver.get_assignment(l4) == l_false);
|
||||
solver.pop_scope(1);
|
||||
SASSERT(solver.get_assignment(l1) == l_undef);
|
||||
SASSERT(solver.get_assignment(l2) == l_undef);
|
||||
SASSERT(solver.get_assignment(l3) == l_undef);
|
||||
SASSERT(solver.get_assignment(l4) == l_undef);
|
||||
}
|
||||
|
||||
static void tst3() {
|
||||
sat_solver<no_extension> solver;
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_var();
|
||||
solver.push_scope();
|
||||
SASSERT(solver.m_ref_count[l1.var()] == 1);
|
||||
solver.mk_aux_clause(~l1, l2, CLS_TRANSIENT);
|
||||
SASSERT(solver.m_ref_count[l1.var()] == 2);
|
||||
solver.assign(l1, mk_axiom());
|
||||
solver.propagate();
|
||||
SASSERT(solver.get_assignment(l2) == l_true);
|
||||
SASSERT(solver.m_transient_clauses.size() == 1);
|
||||
TRACE("sat_ext", tout << "ref_count: " << solver.m_ref_count[l1.var()] << ", scope_lvl: " << solver.m_scope_lvl << "\n";);
|
||||
SASSERT(solver.m_ref_count[l1.var()] == 3);
|
||||
SASSERT(solver.m_ref_count[l2.var()] == 3);
|
||||
solver.pop_scope(1);
|
||||
solver.assign(l1, mk_axiom());
|
||||
solver.propagate();
|
||||
SASSERT(solver.get_assignment(l2) == l_undef);
|
||||
SASSERT(solver.m_transient_clauses.size() == 0);
|
||||
SASSERT(solver.m_ref_count[l1.var()] == 2);
|
||||
SASSERT(solver.m_ref_count[l2.var()] == 1);
|
||||
}
|
||||
|
||||
static void tst4() {
|
||||
sat_solver<no_extension> solver;
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_var();
|
||||
literal l3 = solver.mk_var();
|
||||
literal l4 = solver.mk_var();
|
||||
solver.push_user_scope();
|
||||
solver.mk_aux_clause(~l1, l2, l4, CLS_MAIN);
|
||||
solver.push_user_scope();
|
||||
solver.mk_aux_clause(~l1, ~l2, l3, CLS_MAIN);
|
||||
solver.push_scope();
|
||||
solver.mk_aux_clause(~l3, ~l4, CLS_TRANSIENT);
|
||||
solver.mk_aux_clause(~l1, ~l4, CLS_MAIN);
|
||||
SASSERT(solver.m_ref_count[l1.var()] == 4);
|
||||
SASSERT(solver.m_ref_count[l2.var()] == 3);
|
||||
SASSERT(solver.m_ref_count[l3.var()] == 3);
|
||||
SASSERT(solver.m_ref_count[l4.var()] == 4);
|
||||
SASSERT(solver.m_main_clauses.size() == 3);
|
||||
SASSERT(solver.m_transient_clauses.size() == 1);
|
||||
solver.pop_scope(2);
|
||||
SASSERT(solver.m_ref_count[l1.var()] == 2);
|
||||
SASSERT(solver.m_ref_count[l2.var()] == 2);
|
||||
SASSERT(solver.m_ref_count[l3.var()] == 1);
|
||||
SASSERT(solver.m_ref_count[l4.var()] == 2);
|
||||
SASSERT(solver.m_main_clauses.size() == 1);
|
||||
SASSERT(solver.m_transient_clauses.size() == 0);
|
||||
solver.assign(l1, mk_axiom());
|
||||
SASSERT(solver.get_assignment(l4) == l_undef);
|
||||
solver.pop_scope(1);
|
||||
SASSERT(solver.m_main_clauses.size() == 0);
|
||||
SASSERT(solver.m_ref_count[l1.var()] == 1);
|
||||
SASSERT(solver.m_ref_count[l2.var()] == 1);
|
||||
SASSERT(solver.m_ref_count[l3.var()] == 1);
|
||||
SASSERT(solver.m_ref_count[l4.var()] == 1);
|
||||
}
|
||||
|
||||
template<typename Ext>
|
||||
static void tst5() {
|
||||
sat_solver<Ext> solver;
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_var();
|
||||
solver.push_scope();
|
||||
solver.assign(l1, mk_axiom());
|
||||
solver.push_scope();
|
||||
solver.mk_aux_clause(~l1, l2, CLS_MAIN);
|
||||
SASSERT(solver.get_assignment(l2) == l_true);
|
||||
solver.pop_scope(1);
|
||||
SASSERT(solver.get_assignment(l2) == l_true);
|
||||
solver.pop_scope(1);
|
||||
SASSERT(solver.get_assignment(l2) == l_undef);
|
||||
SASSERT(solver.m_main_clauses.size() == 1);
|
||||
}
|
||||
|
||||
static void tst6() {
|
||||
sat_solver<no_extension> solver;
|
||||
|
||||
literal l = solver.mk_var();
|
||||
solver.assert_lit(l);
|
||||
SASSERT(!solver.inconsistent());
|
||||
solver.push_scope();
|
||||
solver.assign(~l, mk_axiom());
|
||||
SASSERT(solver.inconsistent());
|
||||
solver.pop_scope(1);
|
||||
SASSERT(!solver.inconsistent());
|
||||
}
|
||||
|
||||
class no_ref_count : public no_extension {
|
||||
public:
|
||||
static bool ref_counters_enabled() {
|
||||
return false;
|
||||
}
|
||||
};
|
||||
|
||||
static void tst7() {
|
||||
sat_solver<no_ref_count> solver;
|
||||
literal l1 = solver.mk_var();
|
||||
solver.push_user_scope();
|
||||
literal l2 = solver.mk_var();
|
||||
SASSERT(solver.get_var_vector_size() == 3);
|
||||
solver.pop_scope(1);
|
||||
SASSERT(solver.get_var_vector_size() == 2);
|
||||
}
|
||||
|
||||
static void tst8() {
|
||||
literal l[2];
|
||||
l[0] = true_literal;
|
||||
l[1] = true_literal;
|
||||
clause * cls = clause::mk_clause(2, l, CLS_EXTERNAL);
|
||||
SASSERT(cls->kind() == CLS_EXTERNAL);
|
||||
dealloc(cls);
|
||||
}
|
||||
|
||||
static void tst9() {
|
||||
sat_solver<no_extension> solver;
|
||||
|
||||
solver.push_scope();
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_var();
|
||||
literal l3 = solver.mk_var();
|
||||
solver.mk_aux_clause(l1, l2, l3, CLS_MAIN);
|
||||
solver.pop_scope(1);
|
||||
SASSERT(solver.m_ref_count[l1.var()] == 1);
|
||||
SASSERT(solver.get_assignment(l1) == l_undef);
|
||||
solver.assert_lit(~l2);
|
||||
solver.assert_lit(~l3);
|
||||
solver.propagate();
|
||||
SASSERT(solver.get_assignment(l1) == l_true);
|
||||
SASSERT(solver.m_main_clauses.size() == 1);
|
||||
SASSERT(solver.m_ref_count[l1.var()] == 2);
|
||||
solver.simplify_clauses();
|
||||
SASSERT(solver.m_main_clauses.size() == 0);
|
||||
SASSERT(solver.m_ref_count[l1.var()] == 1);
|
||||
SASSERT(solver.m_weak_ref_count[l1.var()] == 1);
|
||||
SASSERT(solver.get_assignment(l1) == l_true);
|
||||
}
|
||||
|
||||
static void tst10() {
|
||||
sat_solver<no_extension> s;
|
||||
|
||||
literal l1 = s.mk_var();
|
||||
literal l2 = s.mk_var();
|
||||
literal l3 = s.mk_var();
|
||||
|
||||
s.push_scope();
|
||||
s.assign(l1, mk_axiom());
|
||||
s.push_scope();
|
||||
literal l4 = s.mk_var();
|
||||
s.assign(l4, mk_axiom());
|
||||
s.mk_aux_clause(~l4, l3, CLS_TRANSIENT);
|
||||
s.mk_aux_clause(~l4, l2, CLS_TRANSIENT);
|
||||
s.mk_aux_clause(~l3, ~l1, ~l2, CLS_TRANSIENT);
|
||||
SASSERT(s.inconsistent());
|
||||
#ifdef Z3DEBUG
|
||||
bool r =
|
||||
#endif
|
||||
s.resolve_conflict();
|
||||
SASSERT(r);
|
||||
SASSERT(s.m_scope_lvl == 1);
|
||||
SASSERT(s.m_ref_count[l4.var()] > 0);
|
||||
s.pop_scope(1);
|
||||
SASSERT(s.get_assignment(l1) == l_undef);
|
||||
SASSERT(s.get_assignment(l4) == l_undef);
|
||||
s.push_scope();
|
||||
s.assign(l4, mk_axiom());
|
||||
#ifdef Z3DEBUG
|
||||
s.del_learned_clauses();
|
||||
#endif
|
||||
s.pop_scope(1);
|
||||
}
|
||||
|
||||
static void tst11() {
|
||||
// out-of-order conflict bug.
|
||||
sat_solver<no_extension> s;
|
||||
|
||||
literal l1 = s.mk_var();
|
||||
literal l2 = s.mk_var();
|
||||
s.push_scope();
|
||||
s.assign(l1, mk_axiom());
|
||||
s.assign(l2, mk_axiom());
|
||||
s.push_scope();
|
||||
s.mk_aux_clause(~l1, ~l2, CLS_TRANSIENT);
|
||||
s.propagate();
|
||||
s.resolve_conflict();
|
||||
}
|
||||
|
||||
static void tst12() {
|
||||
// out-of-order conflict bug.
|
||||
sat_solver<no_extension> s;
|
||||
|
||||
literal l1 = s.mk_var();
|
||||
literal l2 = s.mk_var();
|
||||
literal l3 = s.mk_var();
|
||||
s.push_scope();
|
||||
s.assign(l1, mk_axiom());
|
||||
s.assign(l2, mk_axiom());
|
||||
s.push_scope();
|
||||
s.assign(l3, mk_axiom());
|
||||
s.mk_aux_clause(~l1, ~l2, CLS_TRANSIENT);
|
||||
s.propagate();
|
||||
s.resolve_conflict();
|
||||
}
|
||||
|
||||
static void tst13() {
|
||||
sat_solver<no_extension> s;
|
||||
literal l1 = s.mk_var();
|
||||
literal l2 = s.mk_var();
|
||||
literal l3 = s.mk_var();
|
||||
s.push_scope();
|
||||
s.assign(l1, mk_axiom());
|
||||
s.push_scope();
|
||||
s.assign(l2, mk_axiom());
|
||||
s.push_scope();
|
||||
s.mk_aux_clause(~l1, l3, CLS_MAIN);
|
||||
s.propagate();
|
||||
SASSERT(!s.inconsistent());
|
||||
SASSERT(s.get_assignment(l3) == l_true);
|
||||
s.mk_aux_clause(~l1, ~l2, CLS_TRANSIENT);
|
||||
s.propagate();
|
||||
SASSERT(s.inconsistent());
|
||||
#ifdef Z3DEBUG
|
||||
bool r =
|
||||
#endif
|
||||
s.resolve_conflict();
|
||||
SASSERT(r);
|
||||
SASSERT(s.get_assignment(l3) == l_true);
|
||||
TRACE("sat", tout << l3 << " : " << s.get_assignment(l3) << " : " << s.m_level[l3.var()] << " : " << s.m_scope_lvl << "\n";);
|
||||
}
|
||||
|
||||
static void tst14() {
|
||||
sat_solver<no_extension> s;
|
||||
literal l1 = s.mk_var();
|
||||
literal l2 = s.mk_var();
|
||||
s.push_scope();
|
||||
s.assign(~l1, mk_axiom());
|
||||
s.push_scope();
|
||||
s.assign(~l2, mk_axiom());
|
||||
s.assert_lit(l1);
|
||||
SASSERT(s.inconsistent());
|
||||
#ifdef Z3DEBUG
|
||||
bool r =
|
||||
#endif
|
||||
s.resolve_conflict();
|
||||
SASSERT(r);
|
||||
SASSERT(s.get_assignment(l1) == l_true);
|
||||
}
|
||||
|
||||
static void tst15() {
|
||||
sat_solver<no_extension> s;
|
||||
literal l1 = s.mk_var();
|
||||
literal l2 = s.mk_var();
|
||||
s.push_scope();
|
||||
s.assign(~l1, mk_axiom());
|
||||
s.push_scope();
|
||||
s.assign(~l2, mk_axiom());
|
||||
s.assert_lit(l1);
|
||||
SASSERT(s.inconsistent());
|
||||
#ifdef Z3DEBUG
|
||||
bool r =
|
||||
#endif
|
||||
s.resolve_conflict();
|
||||
SASSERT(r);
|
||||
SASSERT(s.get_assignment(l1) == l_true);
|
||||
}
|
||||
|
||||
static void tst16() {
|
||||
sat_solver<no_extension> s;
|
||||
s.push_scope();
|
||||
literal l1 = s.mk_var();
|
||||
bool_var v1 = l1.var();
|
||||
s.inc_weak_ref(v1);
|
||||
s.pop_scope(1);
|
||||
SASSERT(s.get_ref_count(v1) == 0);
|
||||
literal l2 = s.mk_var();
|
||||
SASSERT(l2.var() != v1);
|
||||
s.dec_weak_ref(v1);
|
||||
literal l3 = s.mk_var();
|
||||
SASSERT(l3.var() == v1);
|
||||
}
|
||||
|
||||
public:
|
||||
static void run_tests() {
|
||||
enable_trace("sat_ext");
|
||||
enable_trace("backtrack");
|
||||
enable_trace("mk_clause");
|
||||
enable_debug("mk_clause");
|
||||
enable_trace("propagate");
|
||||
enable_trace("simplify");
|
||||
enable_trace("del_learned_clauses");
|
||||
enable_debug("sat_invariant");
|
||||
TRACE("sat_ext", tout << "running SAT solver tests...\n";);
|
||||
tst1();
|
||||
tst2<no_extension>();
|
||||
tst2<no_ref_count>();
|
||||
tst3();
|
||||
tst4();
|
||||
tst5<no_extension>();
|
||||
tst5<no_ref_count>();
|
||||
tst6();
|
||||
tst7();
|
||||
tst8();
|
||||
tst9();
|
||||
tst10();
|
||||
tst11();
|
||||
tst12();
|
||||
tst13();
|
||||
tst14();
|
||||
tst15();
|
||||
tst16();
|
||||
}
|
||||
};
|
||||
|
||||
void tst_sat() {
|
||||
TRACE("sat", tout << "sizeof(clause): " << sizeof(clause) << "\n";);
|
||||
sat_tester::run_tests();
|
||||
}
|
||||
|
||||
|
||||
45
src/dead/test/simplex_polynomial.cpp
Normal file
45
src/dead/test/simplex_polynomial.cpp
Normal file
|
|
@ -0,0 +1,45 @@
|
|||
#include "simplex_polynomial.h"
|
||||
|
||||
void tst_simplex_polynomial()
|
||||
{
|
||||
polynomial p1, p2, p3, p4;
|
||||
simplex_variable v1(1), v2(2), v3(3), v4(4), v5(5);
|
||||
monomial m1(v1), m2(v2), m3(v3), m4(v4);
|
||||
|
||||
m1 = monomial(v1);
|
||||
m1 *= monomial(v2);
|
||||
m1 *= monomial(v1);
|
||||
|
||||
m1.display(std::cout) << std::endl;
|
||||
m1.normalize();
|
||||
m1.display(std::cout) << std::endl;
|
||||
|
||||
m2 = m1;
|
||||
SASSERT(m1 == m2);
|
||||
|
||||
p1 = polynomial(rational(1,2));
|
||||
SASSERT(p1.is_const());
|
||||
|
||||
p1 += polynomial(v1);
|
||||
SASSERT(!p1.is_const());
|
||||
|
||||
p1 += polynomial(v2);
|
||||
p1 *= polynomial(v2);
|
||||
p1 -= polynomial(v3);
|
||||
p1 += polynomial(rational(2,3));
|
||||
|
||||
p1.normalize();
|
||||
p1.display(std::cout) << std::endl;
|
||||
SASSERT(p1[0].size() == 0); // first element is a constant.
|
||||
|
||||
|
||||
p1 = polynomial(v1);
|
||||
p2 = polynomial(v2);
|
||||
p3 = polynomial(v3);
|
||||
p3 += p2;
|
||||
p3 *= p1;
|
||||
|
||||
p3.display(std::cout) << std::endl; // multiplication distributes.
|
||||
SASSERT(p3.size() == 2);
|
||||
|
||||
}
|
||||
101
src/dead/test/template_models.cpp
Normal file
101
src/dead/test/template_models.cpp
Normal file
|
|
@ -0,0 +1,101 @@
|
|||
#include "ast_fm.h"
|
||||
#include "smtparser.h"
|
||||
#include "ast_pp.h"
|
||||
|
||||
static void
|
||||
simplify_formula(
|
||||
ast_manager& ast_manager,
|
||||
smtlib::symtable* table,
|
||||
smtlib::parser* parser,
|
||||
ast* formula
|
||||
)
|
||||
{
|
||||
// front_end_params params;
|
||||
// std::cout << std::make_pair(&ast_manager, formula) << std::endl;
|
||||
|
||||
// const_decl_ast *le_decl = 0, *add_decl = 0, *mul_decl = 0;
|
||||
// const_decl_ast *lt_decl = 0, *gt_decl = 0, *f_decl = 0;
|
||||
// type_decl_ast* int_decl = 0;
|
||||
// type_ast* int_type = 0;
|
||||
|
||||
// table->find1("<=", le_decl);
|
||||
// table->find1("+", add_decl);
|
||||
// table->find1("*", mul_decl);
|
||||
// table->find1("f", f_decl);
|
||||
// table->find1("<", lt_decl);
|
||||
// table->find1(">", gt_decl);
|
||||
// table->find("Int", int_decl);
|
||||
// int_type = ast_manager.mk_type(int_decl);
|
||||
|
||||
|
||||
// ast_simplifier simplifier(ast_manager, params);
|
||||
|
||||
// #if 0
|
||||
// iast_arith_simplifier* arith =
|
||||
// simplifier.add_arithmetic(
|
||||
// null_theory_id, // TBD
|
||||
// add_decl,
|
||||
// mul_decl,
|
||||
// le_decl,
|
||||
// false
|
||||
// );
|
||||
|
||||
// arith->register_lt(lt_decl);
|
||||
// arith->register_gt(gt_decl);
|
||||
// #endif
|
||||
// ast_fm fm(ast_manager, simplifier, le_decl, add_decl, mul_decl);
|
||||
|
||||
// ast_function_replace replace(ast_manager);
|
||||
|
||||
// ast_ref<> templ(ast_manager);
|
||||
// templ = ast_manager.mk_const(add_decl,
|
||||
// ast_manager.mk_var(0,int_type),
|
||||
// ast_manager.mk_numeral(rational(2), int_type));
|
||||
|
||||
// ast_ref<> result(ast_manager);
|
||||
|
||||
// //
|
||||
// // Replace f by \lambda x . x + 2 in formula.
|
||||
// //
|
||||
|
||||
// replace(formula, f_decl, 1, templ.get(), result);
|
||||
|
||||
// std::cout << "substituted:"
|
||||
// << std::make_pair(&ast_manager, result.get()) << std::endl;
|
||||
|
||||
// //
|
||||
// // Eliminate quantified variables from the formula.
|
||||
// //
|
||||
// fm.eliminate(result.get(), result);
|
||||
|
||||
// std::cout << "projected:"
|
||||
// << std::make_pair(&ast_manager, result.get()) << std::endl;
|
||||
|
||||
}
|
||||
|
||||
void tst_template_models()
|
||||
{
|
||||
const char* spec =
|
||||
"(benchmark template_models :logic QF_LIA \n"
|
||||
":extrafuns ((f Int Int) (b Int) (c Int))\n"
|
||||
":formula (forall (x Int) (and (< (f x) (f (+ x 1))) (> (f b) b) (> (f c) b))))";
|
||||
|
||||
ast_manager ast_manager;
|
||||
smtlib::parser* parser = smtlib::parser::create(ast_manager);
|
||||
|
||||
parser->initialize_smtlib();
|
||||
|
||||
parser->parse_string(spec);
|
||||
|
||||
smtlib::benchmark* b = parser->get_benchmark();
|
||||
|
||||
smtlib::symtable* table = b->get_symtable();
|
||||
vector<smtlib::formula,false> formulas;
|
||||
b->get_formulas(formulas);
|
||||
for (unsigned j = 0; j < formulas.size(); ++j) {
|
||||
simplify_formula(ast_manager, table,
|
||||
parser, formulas[j].m_formula);
|
||||
}
|
||||
|
||||
dealloc(parser);
|
||||
}
|
||||
65
src/dead/test/th_propagation.cpp
Normal file
65
src/dead/test/th_propagation.cpp
Normal file
|
|
@ -0,0 +1,65 @@
|
|||
/*++
|
||||
Copyright (c) 2006 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
th_propagation.cpp
|
||||
|
||||
Abstract:
|
||||
|
||||
Test theory propagation.
|
||||
|
||||
Author:
|
||||
|
||||
Leonardo de Moura (leonardo) 2006-11-07.
|
||||
|
||||
Revision History:
|
||||
|
||||
--*/
|
||||
#include"core_theory.h"
|
||||
|
||||
class th_propagation_tester {
|
||||
static void tst1() {
|
||||
core_theory t;
|
||||
t.m_params.m_relevancy_lvl = 0;
|
||||
|
||||
enode * n1 = t.mk_const();
|
||||
enode * n2 = t.mk_const();
|
||||
enode * n3 = t.mk_const();
|
||||
|
||||
literal eq1 = t.mk_eq(n1,n2);
|
||||
literal eq2 = t.mk_eq(n2,n3);
|
||||
literal eq3 = t.mk_eq(n1,n3);
|
||||
|
||||
literal l1 = t.mk_lit();
|
||||
literal l2 = t.mk_lit();
|
||||
t.mk_main_clause(l1, l2, ~eq3);
|
||||
t.mk_main_clause(~l2, ~eq3);
|
||||
t.mk_main_clause(~l1, ~eq2);
|
||||
|
||||
t.push_scope();
|
||||
t.assign(eq1, mk_axiom());
|
||||
t.propagate();
|
||||
|
||||
t.push_scope();
|
||||
t.assign(eq2, mk_axiom());
|
||||
t.propagate();
|
||||
SASSERT(t.get_assignment(eq3) == l_true);
|
||||
SASSERT(t.inconsistent());
|
||||
bool r = t.m_sat->resolve_conflict();
|
||||
SASSERT(r);
|
||||
}
|
||||
|
||||
public:
|
||||
static void run_tests() {
|
||||
enable_trace("th_prop");
|
||||
enable_trace("scope");
|
||||
enable_trace("conflict");
|
||||
tst1();
|
||||
}
|
||||
};
|
||||
|
||||
void tst_th_propagation() {
|
||||
th_propagation_tester::run_tests();
|
||||
}
|
||||
|
||||
42
src/dead/test/trail.cpp
Normal file
42
src/dead/test/trail.cpp
Normal file
|
|
@ -0,0 +1,42 @@
|
|||
/*++
|
||||
Copyright (c) 2006 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
trail.cpp
|
||||
|
||||
Abstract:
|
||||
|
||||
<abstract>
|
||||
|
||||
Author:
|
||||
|
||||
Leonardo de Moura (leonardo) 2007-02-26.
|
||||
|
||||
Revision History:
|
||||
|
||||
--*/
|
||||
#include"core_theory.h"
|
||||
|
||||
void tst_trail() {
|
||||
core_theory t;
|
||||
bvalue<int> v(10);
|
||||
t.push();
|
||||
v.set(t, 20);
|
||||
v.set(t, 30);
|
||||
SASSERT(v.get() == 30);
|
||||
t.pop(1);
|
||||
SASSERT(v.get() == 10);
|
||||
t.push();
|
||||
t.push();
|
||||
v.set(t, 100);
|
||||
SASSERT(v.get() == 100);
|
||||
t.pop(2);
|
||||
SASSERT(v.get() == 10);
|
||||
t.push();
|
||||
t.push();
|
||||
v.set(t, 40);
|
||||
SASSERT(v.get() == 40);
|
||||
t.pop(1);
|
||||
SASSERT(v.get() == 10);
|
||||
}
|
||||
89
src/dead/test/watch_list.cpp
Normal file
89
src/dead/test/watch_list.cpp
Normal file
|
|
@ -0,0 +1,89 @@
|
|||
/*++
|
||||
Copyright (c) 2006 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
tst_watch_list.cpp
|
||||
|
||||
Abstract:
|
||||
|
||||
Test watch list data structure.
|
||||
|
||||
Author:
|
||||
|
||||
Leonardo de Moura (leonardo) 2006-10-02.
|
||||
|
||||
Revision History:
|
||||
|
||||
--*/
|
||||
#include"vector.h"
|
||||
#include"sat_types.h"
|
||||
|
||||
static void tst1() {
|
||||
watch_list wl;
|
||||
for(unsigned i = 0; i < 10; i++)
|
||||
wl.insert_clause(reinterpret_cast<clause*>(static_cast<size_t>(i+1)));
|
||||
}
|
||||
|
||||
static void tst2() {
|
||||
ptr_vector<clause> clause_list;
|
||||
vector<literal> lit_list;
|
||||
watch_list wl;
|
||||
unsigned n = rand()%1000;
|
||||
for (unsigned i = 0; i < n; i++) {
|
||||
unsigned op = rand()%7;
|
||||
if (op <= 1) {
|
||||
clause * c = reinterpret_cast<clause*>(static_cast<size_t>(rand()));
|
||||
wl.insert_clause(c);
|
||||
clause_list.push_back(c);
|
||||
}
|
||||
else if (op <= 3) {
|
||||
literal l = to_literal(rand());
|
||||
wl.insert_literal(l);
|
||||
lit_list.push_back(l);
|
||||
}
|
||||
else if (op <= 4) {
|
||||
if (!clause_list.empty()) {
|
||||
int idx = rand() % (clause_list.size());
|
||||
clause * c = clause_list[idx];
|
||||
wl.remove_clause(c);
|
||||
ptr_vector<clause>::iterator it = std::find(clause_list.begin(), clause_list.end(), c);
|
||||
SASSERT(it);
|
||||
clause_list.erase(it);
|
||||
}
|
||||
}
|
||||
else if (op <= 5) {
|
||||
ptr_vector<clause>::iterator it = clause_list.begin();
|
||||
ptr_vector<clause>::iterator end = clause_list.end();
|
||||
watch_list::clause_iterator it2 = wl.begin_clause();
|
||||
watch_list::clause_iterator end2 = wl.end_clause();
|
||||
for (; it != end; ++it, ++it2) {
|
||||
SASSERT(it2 != end2);
|
||||
SASSERT(*it == *it2);
|
||||
}
|
||||
}
|
||||
else if (op <= 6) {
|
||||
vector<literal>::iterator begin = lit_list.begin();
|
||||
vector<literal>::iterator it = lit_list.end();
|
||||
watch_list::literal_iterator it2 = wl.begin_literals();
|
||||
watch_list::literal_iterator end2 = wl.end_literals();
|
||||
while (it != begin) {
|
||||
--it;
|
||||
SASSERT(it2 != end2);
|
||||
SASSERT(*it == *it2);
|
||||
++it2;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void tst3() {
|
||||
for (unsigned i = 0; i < 1000; i++)
|
||||
tst2();
|
||||
}
|
||||
|
||||
void tst_watch_list() {
|
||||
tst1();
|
||||
tst3();
|
||||
}
|
||||
|
||||
Loading…
Add table
Add a link
Reference in a new issue