mirror of
https://github.com/Z3Prover/z3
synced 2025-06-21 21:33:39 +00:00
Moved dead code to dead branch
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
This commit is contained in:
Leonardo de Moura
parent
8f7494cb04
commit
81df5ca96f
123 changed files with 0 additions and 33328 deletions
|
|
@ -1,42 +0,0 @@
|
|||
#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;);
|
||||
|
||||
}
|
||||
|
|
@ -1,53 +0,0 @@
|
|||
#include "array_property_expander.h"
|
||||
#include "array_property_recognizer.h"
|
||||
#include "smtparser.h"
|
||||
#include "array_decl_plugin.h"
|
||||
#include "ast_pp.h"
|
||||
#include <sstream>
|
||||
|
||||
static void test_array_expand(ast_manager& m, expr* fml) {
|
||||
std::cout << mk_pp(fml, m) << "\n";
|
||||
expr_ref_vector result(m);
|
||||
array_property_expander exp(m);
|
||||
array_property_recognizer rec(m);
|
||||
exp(1, &fml, result);
|
||||
std::cout << mk_pp(result[0].get(), m) << "\n";
|
||||
std::cout << rec(1, &fml) << "\n";
|
||||
}
|
||||
|
||||
|
||||
static void parse_string(char const* fml) {
|
||||
ast_manager m;
|
||||
m.register_plugin(symbol("array"), alloc(array_decl_plugin));
|
||||
scoped_ptr<smtlib::parser> parser = smtlib::parser::create(m);
|
||||
parser->initialize_smtlib();
|
||||
|
||||
std::ostringstream buffer;
|
||||
buffer << "(benchmark array :status unknown :logic AUFLIA \n"
|
||||
<< ":extrafuns ((A (Array Int Int)) (B (Array Int Int)))\n"
|
||||
<< ":extrafuns ((C (Array Int (Array Int Int))))\n"
|
||||
<< ":extrafuns ((D (Array Int Bool Int)))\n"
|
||||
<< ":extrafuns ((i Int) (j Int))\n"
|
||||
<< ":extrafuns ((f Int Int))\n"
|
||||
<< ":formula " << fml << ")";
|
||||
parser->parse_string(buffer.str().c_str());
|
||||
smtlib::benchmark* b = parser->get_benchmark();
|
||||
smtlib::theory::expr_iterator it = b->begin_formulas();
|
||||
smtlib::theory::expr_iterator end = b->end_formulas();
|
||||
for (; it != end; ++it) {
|
||||
test_array_expand(m, *it);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void tst_array_property_expander() {
|
||||
parse_string("(= A B)");
|
||||
parse_string("(= A (store B i 4))");
|
||||
parse_string("(= C (store C 0 (store (select C 0) i 1)))");
|
||||
parse_string("(exists (i Int) (= C (store C 0 (store (select C 0) i 1))))");
|
||||
parse_string("(forall (i Int) (b Bool) (= D (store D i b 4)))");
|
||||
parse_string("(= (const[Array] 3) A)");
|
||||
parse_string("(= (map[f] A) B)");
|
||||
|
||||
}
|
||||
|
||||
|
|
@ -1,821 +0,0 @@
|
|||
/*++
|
||||
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();
|
||||
}
|
||||
|
||||
|
|
@ -1,75 +0,0 @@
|
|||
/*++
|
||||
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();
|
||||
}
|
||||
|
|
@ -1,296 +0,0 @@
|
|||
/*++
|
||||
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();
|
||||
}
|
||||
|
||||
|
|
@ -1,63 +0,0 @@
|
|||
#include "expr_context_simplifier.h"
|
||||
#include "smtparser.h"
|
||||
#include "ast_pp.h"
|
||||
#include "reg_decl_plugins.h"
|
||||
|
||||
static void check_equiv(ast_manager& m, expr* e1, expr* e2) {
|
||||
front_end_params fp;
|
||||
smt::solver solver(m, fp);
|
||||
expr_ref equiv(m);
|
||||
equiv = m.mk_not(m.mk_eq(e1,e2));
|
||||
solver.assert_expr(equiv);
|
||||
lbool is_sat = solver.check();
|
||||
SASSERT(is_sat == l_false);
|
||||
}
|
||||
|
||||
static void simplify_formula(ast_manager& m, expr* e) {
|
||||
expr_ref result(m);
|
||||
expr_context_simplifier simp(m);
|
||||
|
||||
simp(e, result);
|
||||
|
||||
TRACE("expr_context_simplifier",
|
||||
tout
|
||||
<< mk_pp(e, m) << "\n|->\n"
|
||||
<< mk_pp(result.get(), m) << "\n";);
|
||||
|
||||
check_equiv(m, e, result);
|
||||
|
||||
}
|
||||
|
||||
void tst_expr_context_simplifier() {
|
||||
ast_manager m;
|
||||
|
||||
smtlib::parser* parser = smtlib::parser::create(m);
|
||||
reg_decl_plugins(m);
|
||||
|
||||
parser->initialize_smtlib();
|
||||
|
||||
parser->parse_string(
|
||||
"(benchmark samples :logic QF_LIA \n"
|
||||
" :extrafuns ((x Int) (y Int) (z Int) (u Int)) \n"
|
||||
" :extrapreds ((p) (q) (r)) \n"
|
||||
" :formula (and (<= 1 x) (or (<= 1 x) (<= x y))) \n"
|
||||
" :formula (and (<= 2 (ite (<= z 1) (ite (<= z 1) x y) (* 2 x))) (<= x y)) \n"
|
||||
" :formula (or (and (not p) q (or (not r) (and (or (not p) q) r)))\
|
||||
(and (not p) q (or (and p (not q) r) (and (or (not p) q) (not r)))) \
|
||||
(and (or (and p (not q)) (and p q))\
|
||||
(or (and p q r) (and (or (not p) (not q)) (not r))))\
|
||||
(and (not p) (not q) (or (and (not p) q r) (and (or p (not q)) (not r))))\
|
||||
(and (not p) (not q) (or (not r) (and (or p (not q)) r))))\n"
|
||||
")"
|
||||
);
|
||||
|
||||
smtlib::benchmark* b = parser->get_benchmark();
|
||||
|
||||
smtlib::symtable const * table = b->get_symtable();
|
||||
|
||||
for (unsigned j = 0; j < b->get_num_formulas(); ++j) {
|
||||
simplify_formula(m, b->begin_formulas()[j]);
|
||||
}
|
||||
|
||||
dealloc(parser);
|
||||
}
|
||||
|
|
@ -1,101 +0,0 @@
|
|||
/*++
|
||||
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();
|
||||
}
|
||||
|
|
@ -1,472 +0,0 @@
|
|||
/*++
|
||||
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();
|
||||
}
|
||||
|
|
@ -1,243 +0,0 @@
|
|||
/*++
|
||||
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>();
|
||||
}
|
||||
|
|
@ -1,58 +0,0 @@
|
|||
#include "z3.h"
|
||||
#include <windows.h>
|
||||
|
||||
class thread_check {
|
||||
|
||||
CRITICAL_SECTION m_cs;
|
||||
|
||||
static DWORD __stdcall do_check(LPVOID _this) {
|
||||
thread_check* th = static_cast<thread_check*>(_this);
|
||||
Z3_config cfg = Z3_mk_config();
|
||||
Z3_set_param_value(cfg,"MODEL","true");
|
||||
Z3_context ctx = Z3_mk_context(cfg);
|
||||
Z3_parse_smtlib_string(ctx, "(benchmark b :logic QF_UF :extrafuns ((f U U) (x U)) :formula (= (f x) x))", 0, 0, 0, 0, 0, 0);
|
||||
Z3_ast f = Z3_get_smtlib_formula(ctx, 0);
|
||||
Z3_assert_cnstr(ctx, f);
|
||||
Z3_model m = 0;
|
||||
Z3_lbool r = Z3_check_and_get_model(ctx,&m);
|
||||
EnterCriticalSection(&th->m_cs);
|
||||
printf("%d\n", r);
|
||||
LeaveCriticalSection(&th->m_cs);
|
||||
if (m) {
|
||||
Z3_del_model(ctx, m);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
public:
|
||||
thread_check() {
|
||||
InitializeCriticalSection(&m_cs);
|
||||
}
|
||||
|
||||
~thread_check() {
|
||||
DeleteCriticalSection(&m_cs);
|
||||
}
|
||||
|
||||
void do_checks(unsigned num_threads) {
|
||||
HANDLE* handles = new HANDLE[num_threads];
|
||||
for (unsigned i = 0; i < num_threads; ++i) {
|
||||
HANDLE hThread = CreateThread(NULL, 0, &thread_check::do_check, this, 0, 0);
|
||||
handles[i] = hThread;
|
||||
}
|
||||
|
||||
WaitForMultipleObjects(num_threads, handles, TRUE, INFINITE);
|
||||
|
||||
for (unsigned i = 0; i < num_threads; ++i) {
|
||||
CloseHandle(handles[i]);
|
||||
}
|
||||
delete[] handles;
|
||||
}
|
||||
};
|
||||
|
||||
extern "C"
|
||||
__declspec(dllexport) int ChessTestRun() {
|
||||
thread_check tc;
|
||||
tc.do_checks(2);
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,70 +0,0 @@
|
|||
#ifdef _WINDOWS
|
||||
|
||||
#include "z3.h"
|
||||
#include "z3_private.h"
|
||||
#include <iostream>
|
||||
#include "util.h"
|
||||
#include "trace.h"
|
||||
#include <map>
|
||||
#include "trace.h"
|
||||
#include "vector.h"
|
||||
#include "buffer.h"
|
||||
#undef ARRAYSIZE
|
||||
#include <windows.h>
|
||||
|
||||
class thread_check {
|
||||
|
||||
CRITICAL_SECTION m_cs;
|
||||
|
||||
static DWORD __stdcall do_check(LPVOID _this) {
|
||||
thread_check* th = static_cast<thread_check*>(_this);
|
||||
Z3_config cfg = Z3_mk_config();
|
||||
Z3_set_param_value(cfg,"MODEL","true");
|
||||
Z3_context ctx = Z3_mk_context(cfg);
|
||||
Z3_parse_smtlib_string(ctx, "(benchmark b :logic QF_UF :extrafuns ((f U U) (x U)) :formula (= (f x) x))", 0, 0, 0, 0, 0, 0);
|
||||
Z3_ast f = Z3_get_smtlib_formula(ctx, 0);
|
||||
Z3_assert_cnstr(ctx, f);
|
||||
Z3_model m = 0;
|
||||
Z3_lbool r = Z3_check_and_get_model(ctx,&m);
|
||||
EnterCriticalSection(&th->m_cs);
|
||||
printf("%d\n", r);
|
||||
LeaveCriticalSection(&th->m_cs);
|
||||
if (m) {
|
||||
Z3_del_model(ctx, m);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
public:
|
||||
thread_check() {
|
||||
InitializeCriticalSection(&m_cs);
|
||||
}
|
||||
|
||||
~thread_check() {
|
||||
DeleteCriticalSection(&m_cs);
|
||||
}
|
||||
|
||||
void do_checks(unsigned num_threads) {
|
||||
ptr_buffer<void> handles;
|
||||
for (unsigned i = 0; i < num_threads; ++i) {
|
||||
HANDLE hThread = CreateThread(NULL, 0, &thread_check::do_check, this, 0, 0);
|
||||
handles.push_back(hThread);
|
||||
}
|
||||
|
||||
WaitForMultipleObjects(handles.size(), handles.c_ptr(), TRUE, INFINITE);
|
||||
|
||||
for (unsigned i = 0; i < handles.size(); ++i) {
|
||||
CloseHandle(handles[i]);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
void tst_parallel() {
|
||||
thread_check tc;
|
||||
tc.do_checks(2);
|
||||
}
|
||||
#else
|
||||
void tst_parallel() {
|
||||
}
|
||||
#endif
|
||||
|
|
@ -1,500 +0,0 @@
|
|||
#include "ast.h"
|
||||
#include "front_end_params.h"
|
||||
#include "simplifier.h"
|
||||
#include "qe.h"
|
||||
#include "basic_simplifier_plugin.h"
|
||||
#include "arith_simplifier_plugin.h"
|
||||
#include "array_simplifier_plugin.h"
|
||||
#include "bv_simplifier_plugin.h"
|
||||
#include "ast_pp.h"
|
||||
#include "smtlib.h"
|
||||
#include "smtparser.h"
|
||||
#include "lbool.h"
|
||||
#include <sstream>
|
||||
#include "reg_decl_plugins.h"
|
||||
|
||||
|
||||
static void test_qe(ast_manager& m, lbool expected_outcome, expr* fml, char const* option) {
|
||||
|
||||
// enable_trace("bit2int");
|
||||
//enable_trace("gomory_cut");
|
||||
enable_trace("final_check_arith");
|
||||
enable_trace("arith_final_check");
|
||||
//enable_trace("arith_branching");
|
||||
enable_trace("theory_arith_int");
|
||||
enable_trace("presburger");
|
||||
enable_trace("quant_elim");
|
||||
// enable_trace("arith_simplifier_plugin");
|
||||
// enable_trace("non_linear");
|
||||
// enable_trace("gomory_cut_detail");
|
||||
// enable_trace("arith");
|
||||
// enable_trace("bv");
|
||||
// enable_trace("after_search");
|
||||
// enable_trace("bv_bit_prop");
|
||||
|
||||
simplifier simp(m);
|
||||
front_end_params params;
|
||||
params.m_quant_elim = true;
|
||||
|
||||
std::cout << mk_pp(fml, m) << "\n";
|
||||
qe::expr_quant_elim qe(m, params);
|
||||
expr_ref result(m);
|
||||
qe(m.mk_true(), fml, result);
|
||||
std::cout << " -> " << mk_pp(result, m) << " " << expected_outcome << "\n";
|
||||
if (expected_outcome == l_true && !m.is_true(result)) {
|
||||
std::cout << "ERROR: expected true, instead got " << ast_pp(result, m).c_str() << "\n";
|
||||
//exit(-1);
|
||||
}
|
||||
if (expected_outcome == l_false && !m.is_false(result)) {
|
||||
std::cout << "ERROR: expected false, instead got " << ast_pp(result, m).c_str() << "\n";
|
||||
//exit(-1);
|
||||
}
|
||||
}
|
||||
|
||||
static void test_formula(lbool expected_outcome, char const* fml) {
|
||||
ast_manager m;
|
||||
reg_decl_plugins(m);
|
||||
scoped_ptr<smtlib::parser> parser = smtlib::parser::create(m);
|
||||
parser->initialize_smtlib();
|
||||
|
||||
std::ostringstream buffer;
|
||||
buffer << "(benchmark presburger :status unknown :logic AUFLIA :extrapreds ((p1) (p2) (p3)) "
|
||||
<< ":extrafuns ((a Int) (b Int))\n"
|
||||
<< ":extrapreds ((p) (q) (r))\n"
|
||||
<< ":datatypes ((list (nil) (cons (hd Int) (tl list))))\n"
|
||||
<< ":datatypes ((cell (cnil) (ccons (car cell) (cdr cell))))\n"
|
||||
<< ":extrasorts (U)\n"
|
||||
<< ":extrafuns ((f U U))\n"
|
||||
<< ":formula " << fml << ")";
|
||||
parser->parse_string(buffer.str().c_str());
|
||||
smtlib::benchmark* b = parser->get_benchmark();
|
||||
smtlib::theory::expr_iterator it = b->begin_formulas();
|
||||
smtlib::theory::expr_iterator end = b->end_formulas();
|
||||
for (; it != end; ++it) {
|
||||
test_qe(m, expected_outcome, *it, 0);
|
||||
}
|
||||
}
|
||||
|
||||
void tst_quant_elim() {
|
||||
|
||||
test_formula(l_undef, "(exists ((p1 Bool) (q1 Bool) (r1 Bool))\
|
||||
(and (or (not p1) (not q1) r1)\
|
||||
(or (and (not p) (not q) (not p1) q1)\
|
||||
(and (not p) q p1 (not q1))\
|
||||
(and p (not q) p1 q1)\
|
||||
(and p q p1 q1))\
|
||||
(or (and (not r) (not r1))\
|
||||
(and (= p p1) (= q q1) r r1)\
|
||||
(and (not (and (= p p1) (= q q1))) (not (= r r1))))))");
|
||||
|
||||
|
||||
test_formula(l_false,"(forall (x Int) (y Int) (or (= x 0) (< (* 5 y) (* 6 x)) (> (* 5 y) (* 6 x))))");
|
||||
|
||||
test_formula(l_false, "(forall (a Int) (b Int) (exists (x Int) (and (< a (* 20 x)) (< (* 20 x) b))))");
|
||||
|
||||
test_formula(l_undef, "(exists (u U) (= (f u) u))");
|
||||
|
||||
test_formula(l_true,
|
||||
"(exists (l Int) (forall (x Int) (implies (>= x l) "
|
||||
" (exists (u Int) (v Int) (and (>= u 0) (>= v 0) (= x (+ (* 3 u) (* 7 v))))))))");
|
||||
|
||||
|
||||
test_formula(l_true, "(forall (x Int) (y Int) (implies (= (* 6 x) (* 5 y)) (exists (d Int) (= y (* 3 d)))))");
|
||||
|
||||
test_formula(l_undef, "(exists (x Int) (= (- a (mod x 4)) 0))");
|
||||
// return;
|
||||
|
||||
|
||||
// test_formula(l_true, "(exists (x Int) (y Int) (= 1 (+ (* 5 x) (* 3 y))))");
|
||||
|
||||
|
||||
test_formula(l_undef, "(exists (a Bool) (b Bool) (or (and p1 a) (and p2 (not b))))");
|
||||
|
||||
|
||||
|
||||
|
||||
test_formula(l_false,
|
||||
"(forall (x Int) (q1 Int) (q2 Int) (r1 Int) (r2 Int) "
|
||||
" (implies "
|
||||
" (and (< x 4699) "
|
||||
" (= (* 2622 x) (+ (* 65536 q1) r1)) "
|
||||
" (<= 0 q1) "
|
||||
" (<= 0 r1) "
|
||||
" (< r1 65536) "
|
||||
" (= x (+ (* 100 q2) r2)) "
|
||||
" (<= 0 q2) "
|
||||
" (<= 0 r2) "
|
||||
" (< r2 100)) "
|
||||
" (= q1 q2)))");
|
||||
|
||||
|
||||
|
||||
test_formula(l_undef,
|
||||
"(forall (l list) (or (= l nil) (exists (x Int) (ll list) (= l (cons x ll)))))");
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
test_formula(l_false, "(exists (x Real) (forall (y Real) (>= x y)))");
|
||||
test_formula(l_false, "(exists (x Real) (forall (y Real) (> x y)))");
|
||||
test_formula(l_false, "(exists (x Real) (forall (y Real) (< x y)))");
|
||||
test_formula(l_false, "(exists (x Real) (forall (y Real) (<= x y)))");
|
||||
|
||||
test_formula(l_true, "(exists (x Real) (exists (y Real) (< x y)))");
|
||||
test_formula(l_true, "(exists (x Real) (exists (y Real) (<= x y)))");
|
||||
test_formula(l_true, "(exists (x Real) (exists (y Real) (>= x y)))");
|
||||
test_formula(l_true, "(exists (x Real) (exists (y Real) (> x y)))");
|
||||
|
||||
test_formula(l_true, "(forall (x Real) (exists (y Real) (< x y)))");
|
||||
test_formula(l_true, "(forall (x Real) (exists (y Real) (<= x y)))");
|
||||
test_formula(l_true, "(forall (x Real) (exists (y Real) (>= x y)))");
|
||||
test_formula(l_true, "(forall (x Real) (exists (y Real) (> x y)))");
|
||||
|
||||
test_formula(l_false, "(forall (x Real) (forall (y Real) (< x y)))");
|
||||
test_formula(l_false, "(forall (x Real) (forall (y Real) (<= x y)))");
|
||||
test_formula(l_false, "(forall (x Real) (forall (y Real) (>= x y)))");
|
||||
test_formula(l_false, "(forall (x Real) (forall (y Real) (> x y)))");
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
test_formula(l_true,
|
||||
"(exists (l Int) (forall (x Int) (implies (>= x l) "
|
||||
" (exists (u Int) (v Int) (and (>= u 0) (>= v 0) (= x (+ (* 3 u) (* 5 v))))))))");
|
||||
|
||||
|
||||
test_formula(l_false, "(forall (d Int) (implies (>= d 0) (exists (x Int) (y Int) (and (>= x 0) (>= y 0) (= d (+ (* 3 x) (* 5 y)))))))");
|
||||
|
||||
test_formula(l_true, "(forall (y Int) (implies (exists (d Int) (= y (* 6 d))) (exists (d Int) (= y (* 2 d)))))");
|
||||
|
||||
test_formula(l_true, "(forall (y Int) (implies (exists (d Int) (= y (* 65 d))) (exists (d Int) (= y (* 5 d)))))");
|
||||
|
||||
|
||||
test_formula(l_true,
|
||||
"(exists (z Int) (forall (w Int) (exists (x Int) (y Int) "
|
||||
" (or (and (< (+ (* 3 x) w) 2) (< 1 (- (+ (* 2 x) z) w))) "
|
||||
" (and (< z (* 2 y)) (> z y))))))");
|
||||
|
||||
|
||||
test_formula(l_true, "(exists (x Int) (y Int) (and (> x 0) (>= y 0) (= 1 (- (* 3 x) (* 5 y)))))");
|
||||
|
||||
|
||||
test_formula(l_true,
|
||||
"(exists (a Int) (b Int) "
|
||||
" (and (not (= a 1)) (= a b) (or (= a (* 2 b)) (= (* 2 b) (+ 1 (* 3 a))))))");
|
||||
|
||||
|
||||
|
||||
test_formula(l_true,
|
||||
"(forall (x Int) (iff (and (not (= 0 (mod x 2))) (= 0 (mod (- x 1) 3))) "
|
||||
" (or (= 0 (mod (- x 1) 12)) (= 0 (mod (- x 7) 12)))))");
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
test_formula(l_false, "(exists (x Int) (and (< (* 3 x) 2) (< 1 (* 2 x))))");
|
||||
|
||||
|
||||
test_formula(l_true, "(forall (x Int) (y Int) (or (= 0 (mod x 5)) (not (= (* 6 x) (* 5 y)))))");
|
||||
|
||||
|
||||
test_formula(l_false, "(forall (x Int) (exists (y Int) (= x (* 2 y))))");
|
||||
test_formula(l_false,
|
||||
"(forall (x Int) "
|
||||
" (implies (not (= 0 (mod x 2))) "
|
||||
" (or (= 0 (mod (- x 1) 4)) "
|
||||
" (= 0 (mod (- x 1) 8)) "
|
||||
" (= 0 (mod (- x 3) 8)) "
|
||||
" (= 0 (mod (- x 1) 6)) "
|
||||
" (= 0 (mod (- x 1) 14)) "
|
||||
" (= 0 (mod (- x 9) 14)) "
|
||||
" (= 0 (mod (- x 11) 14)) "
|
||||
" (= 0 (mod (- x 5) 24)) "
|
||||
" (= 0 (mod (- x 11) 24))))) ");
|
||||
|
||||
test_formula(l_true,
|
||||
"(forall (x Int) (iff (and (not (= 0 (mod x 2))) (= 0 (mod (- x 1) 3))) "
|
||||
" (or (= 0 (mod (- x 1) 12)) (= 0 (mod (- x 7) 12)))))");
|
||||
|
||||
|
||||
|
||||
|
||||
test_formula(l_false,
|
||||
"(forall (d Int) (c Int) (b Int) "
|
||||
" (and (= c 0) (= d (* b c)) (= d 0)))");
|
||||
|
||||
|
||||
|
||||
|
||||
//return;
|
||||
|
||||
test_formula(l_undef, "(exists (k!12 Int) (k!11 Int) (and (= (ite (= k!11 0) 0 k!11) k!11) (not (= (ite (= k!12 (+ 1)) 1 0) 0))))");
|
||||
//return;
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
test_formula(l_false,
|
||||
"(forall (a Int) (b Int) (x Int) (y Int) (z Int) "
|
||||
" (implies (and (= (+ a 2) b) (= x (+ 1 (- b a))) (= y (- b 2)) (= z 3)) false))");
|
||||
|
||||
|
||||
|
||||
test_formula(l_false,
|
||||
"(exists (a Int) (b Int) "
|
||||
" (and (> a 1) (> b 1) (= a b) (or (= a (* 2 b)) (= (* 2 b) (+ 1 (* 3 a))))))");
|
||||
|
||||
|
||||
|
||||
test_formula(l_true, "(forall (d Int) (implies true (exists (x Int) (y Int) (and true true (= d (+ (* 3 x) (* 5 y)))))))");
|
||||
|
||||
// This one takes forever without bit-vectors
|
||||
test_formula(l_true, "(forall (d Int) (implies (>= d 8) (exists (x Int) (y Int) (and (>= x 0) (>= y 0) (= d (+ (* 3 x) (* 5 y)))))))");
|
||||
|
||||
test_formula(l_true, "(forall (d Int) (implies (>= d 0) (exists (x Int) (y Int) (and (>= x 0) (>= y 0) (= d (- (* 3 x) (* 5 y)))))))");
|
||||
|
||||
|
||||
test_formula(l_false, "(exists (x Int) (y Int) (z Int) (= 1 (- (* 4 x) (* 6 y))))");
|
||||
|
||||
//return;
|
||||
|
||||
|
||||
|
||||
test_formula(l_true,
|
||||
"(exists (l Int) (forall (x Int) (implies (>= x l) "
|
||||
" (exists (u Int) (v Int) (and (>= u 0) (>= v 0) (= x (+ (* 3 u) (* 8 v))))))))");
|
||||
|
||||
test_formula(l_true,
|
||||
"(exists (l Int) (forall (x Int) (implies (>= x l) "
|
||||
" (exists (u Int) (v Int) (and (>= u 0) (>= v 0) (= x (+ (* 3 u) (* 8 v))))))))");
|
||||
|
||||
#if 0
|
||||
|
||||
// too slow.
|
||||
|
||||
test_formula(l_true,
|
||||
"(exists (l Int) (forall (x Int) (implies (>= x l) "
|
||||
" (exists (u Int) (v Int) (and (>= u 0) (>= v 0) (= x (+ (* 7 u) (* 8 v))))))))");
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
test_formula(l_true, "(forall (x Int) (exists (y Int) (and (<= (* 2 y) x) (< x (* 2 (+ y 1))))))");
|
||||
|
||||
|
||||
test_formula(l_false, "(exists (x Int) (y Int) (and (> y 0) (> y (* 2 x)) (< y (+ x 2)) (= 0 (mod y 2))))");
|
||||
|
||||
test_formula(l_false, "(exists (x Int) (and (< (* 3 x) 3) (< 1 (* 2 x))))");
|
||||
|
||||
|
||||
test_formula(l_true, "(exists (x Int) (and (< (* 3 x) 4) (< 1 (* 2 x))))");
|
||||
|
||||
test_formula(l_false, "(exists (x Int) (and (< (+ (* 3 x) 1) 10) (> (- (* 7 x) 6) 7) (= 0 (mod x 3))))");
|
||||
|
||||
|
||||
test_formula(l_false, "(exists (x Int) (y Int) (and (< (- 1 (* 5 y)) x) (< (+ 1 y) (* 13 x)) (< (+ x 2) 0) (> y 0)))");
|
||||
|
||||
test_formula(l_false, "(exists (x Int) (y Int) (and (< (- 1 (* 5 y)) x) (< (+ 1 y) (* 13 x)) (< x -2)))");
|
||||
|
||||
test_formula(l_true, "(exists (w Int) (z Int) (y Int) (x Int) (and (< (- 1 (* 5 y)) (+ x (* 2 z))) (< (+ 1 y w (* -4 z)) (* 13 x)) (< x -2) (> z 0)))");
|
||||
|
||||
|
||||
|
||||
test_formula(l_true,
|
||||
"(forall (w Int) "
|
||||
" (exists (z Int) (y Int) (x Int) "
|
||||
" (and (< (- 1 (* 5 y)) (+ x (* 2 z))) "
|
||||
" (< (- (+ 1 y) (* 4 z)) (* 13 x)) "
|
||||
" (< x -2) (> z 0) (< x 10)))) ");
|
||||
|
||||
|
||||
test_formula(l_false,
|
||||
"(forall (d Int) (c Int) (b Int) "
|
||||
" (and (= c 0) (= d (* b c)) (= d 4)))");
|
||||
|
||||
test_formula(l_undef,
|
||||
"(exists (d Int) (c Int) (b Int) "
|
||||
" (and (= c 0) (= d (* b c)) (= d 0)))");
|
||||
|
||||
test_formula(l_undef,
|
||||
"(exists (d Int) (c Int) (b Int) "
|
||||
" (and (= c 0) (= d (* b c)) (= d 4)))");
|
||||
|
||||
|
||||
|
||||
// Tests from Harrison's HOL-light version of Cooper.
|
||||
|
||||
test_formula(l_true, "(forall (x Int) (y Int) (not (= (+ 1 (* 2 x)) (* 2 y))))");
|
||||
|
||||
|
||||
test_formula(l_false, "(exists (x Int) (y Int) (= 1 (- (* 4 x) (* 6 y))))");
|
||||
|
||||
|
||||
|
||||
// "(forall (x Int) (implies (< b x) (<= a x)))"
|
||||
// "(forall (x Int) (implies (< b x) (< a x)))"
|
||||
|
||||
|
||||
test_formula(l_false, "(forall (d Int) (implies (>= d 0) (exists (x Int) (y Int) (and (>= x 0) (>= y 0) (= d (+ (* 3 x) (* 5 y)))))))");
|
||||
|
||||
test_formula(l_true, "(forall (d Int) (implies true (exists (x Int) (y Int) (and true true (= d (+ (* 3 x) (* 5 y)))))))");
|
||||
|
||||
// This one takes forever without bit-vectors
|
||||
test_formula(l_true, "(forall (d Int) (implies (>= d 8) (exists (x Int) (y Int) (and (>= x 0) (>= y 0) (= d (+ (* 3 x) (* 5 y)))))))");
|
||||
|
||||
test_formula(l_true, "(forall (d Int) (implies (>= d 0) (exists (x Int) (y Int) (and (>= x 0) (>= y 0) (= d (- (* 3 x) (* 5 y)))))))");
|
||||
|
||||
test_formula(l_true, "(exists (x Int) (y Int) (and (> x 0) (>= y 0) (= 1 (- (* 3 x) (* 5 y)))))");
|
||||
|
||||
test_formula(l_false, "(exists (x Int) (y Int) (z Int) (= 1 (- (* 4 x) (* 6 y))))");
|
||||
|
||||
// "(forall (x Int) (implies (< b (* 3 x)) (a < (* 3 x))))"
|
||||
|
||||
test_formula(l_false, "(forall (x Int) (y Int) (implies (<= x y) (< (+ 1 (* 2 x)) (* 2 y))))");
|
||||
|
||||
|
||||
test_formula(l_true, "(forall (x Int) (y Int) (z Int) (implies (= (+ 1 (* 2 x)) (* 2 y)) (> (+ x y z) 129)))");
|
||||
|
||||
// Formula examples from Cooper's paper.
|
||||
|
||||
|
||||
test_formula(l_true, "(forall (a Int) (exists (b Int) (or (< a (+ (* 4 b) (* 3 a))) (and (not (< a b)) (> a (+ b 1))))))");
|
||||
|
||||
test_formula(l_false, "(exists (y Int) (forall (x Int) (and (> (+ x (* 5 y)) 1) (> (- (* 13 x) y) 1) (< (+ x 2) 0))))");
|
||||
|
||||
// Harrison's formulas:
|
||||
|
||||
test_formula(l_false, "(forall (x Int) (y Int) (implies (and (>= x 0) (>= y 0)) (or (< (- (* 12 x) (* 8 y)) 0) (> (- (* 12 x) (* 8 y)) 2))))");
|
||||
|
||||
|
||||
// test_formula(l_true, "(exists (x Int) (y Int) (= 1 (+ (* 5 x) (* 3 y))))");
|
||||
|
||||
|
||||
test_formula(l_false, "(exists (x Int) (y Int) (= 1 (+ (* 5 x) (* 10 y))))");
|
||||
|
||||
test_formula(l_true, "(exists (x Int) (y Int) (and (>= x 0) (>= y 0) (= 1 (- (* 5 x) (* 6 y)))))");
|
||||
|
||||
test_formula(l_true, "(exists (x Int) (y Int) (z Int) (w Int) (= 1 (+ (* 2 w) (* 3 x) (* 4 y) (* 5 z))))");
|
||||
|
||||
test_formula(l_true, "(exists (x Int) (y Int) (and (>= x 0) (>= y 0) (= 1 (- (* 5 x) (* 3 y)))))");
|
||||
|
||||
test_formula(l_true, "(exists (x Int) (y Int) (and (>= x 0) (>= y 0) (= 1 (- (* 3 x) (* 5 y)))))");
|
||||
|
||||
test_formula(l_false,"(exists (x Int) (y Int) (and (>= x 0) (>= y 0) (= 1 (- (* 6 x) (* 3 y)))))");
|
||||
|
||||
test_formula(l_true, "(forall (x Int) (y Int) (or (= 0 (mod x 5)) (= 0 (mod y 6)) (not (= (* 6 x) (* 5 y)))))");
|
||||
|
||||
|
||||
test_formula(l_false,"(forall (x Int) (y Int) (or (not (= (* 6 x) (* 5 y)))))");
|
||||
|
||||
|
||||
|
||||
// Positive variant of the Bezout theorem (see the exercise). *)
|
||||
|
||||
test_formula(l_true, "(forall (z Int) (implies (> z 7) (exists (x Int) (y Int) (and (>= x 0) (>= y 0) (= (+ (* 3 x) (* 5 y)) z)))))");
|
||||
|
||||
test_formula(l_false,"(forall (z Int) (implies (> z 2) (exists (x Int) (y Int) (and (>= x 0) (>= y 0) (= (+ (* 3 x) (* 5 y)) z)))))");
|
||||
|
||||
test_formula(l_true,
|
||||
"(forall (z Int) (implies (<= z 7) "
|
||||
" (iff (exists (x Int) (y Int) (and (>= x 0) (>= y 0) (= z (+ (* 3 x) (* 5 y))))) "
|
||||
" (not (exists (x Int) (y Int) (and (>= x 0) (>= y 0) (= (- 7 z) (+ (* 3 x) (* 5 y))))))))) ");
|
||||
|
||||
// Basic result about congruences.
|
||||
|
||||
test_formula(l_true,
|
||||
"(forall (x Int) "
|
||||
" (iff (and (not (exists (m Int) (= x (* 2 m)))) (exists (m Int) (= x (+ (* 3 m) 1)))) "
|
||||
" (or (exists (m Int) (= x (+ (* 12 m) 1))) (exists (m Int) (= x (+ (* 12 m) 7))))))");
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
// Inspired by the Collatz conjecture.
|
||||
|
||||
test_formula(l_false,
|
||||
"(forall (a Int) (b Int) (x Int) (y Int) (z Int) "
|
||||
" (implies (and (= (+ a 2) b) (= x (+ 1 (- b a))) (= y (- b 2)) (= z 3)) false))");
|
||||
|
||||
test_formula(l_true,
|
||||
"(exists (a Int) (b Int) "
|
||||
" (and (not (= a 1)) (= a b) (or (= a (* 2 b)) (= (* 2 b) (+ 1 (* 3 a))))))");
|
||||
|
||||
|
||||
test_formula(l_false,
|
||||
"(exists (a Int) (b Int) "
|
||||
" (and (> a 1) (> b 1) (= a b) (or (= a (* 2 b)) (= (* 2 b) (+ 1 (* 3 a))))))");
|
||||
|
||||
test_formula(l_false,
|
||||
"(exists (a Int) (b Int) "
|
||||
" (and (> a 1) (> b 1) "
|
||||
" (or (= a (* 2 b)) (= (* 2 b) (+ 1 (* 3 a)))) "
|
||||
" (or (= b (* 2 a)) (= (* 2 a) (+ 1 (* 3 b))))))");
|
||||
|
||||
#if 0
|
||||
// Bob Constable's "stamp problem".
|
||||
|
||||
test_formula(l_true,
|
||||
"(forall (x Int) (implies (>= x 8) "
|
||||
" (exists (u Int) (v Int) (and (>= u 0) (>= v 0) (= x (+ (* 3 u) (* 5 v)))))))");
|
||||
|
||||
test_formula(l_true,
|
||||
"(exists (l Int) (forall (x Int) (implies (>= x l) "
|
||||
" (exists (u Int) (v Int) (and (>= u 0) (>= v 0) (= x (+ (* 3 u) (* 5 v))))))))");
|
||||
|
||||
test_formula(l_true,
|
||||
"(exists (l Int) (forall (x Int) (implies (>= x l) "
|
||||
" (exists (u Int) (v Int) (and (>= u 0) (>= v 0) (= x (+ (* 3 u) (* 7 v))))))))");
|
||||
|
||||
test_formula(l_true,
|
||||
"(exists (l Int) (forall (x Int) (implies (>= x l) "
|
||||
" (exists (u Int) (v Int) (and (>= u 0) (>= v 0) (= x (+ (* 3 u) (* 8 v))))))))");
|
||||
|
||||
test_formula(l_true,
|
||||
"(exists (l Int) (forall (x Int) (implies (>= x l) "
|
||||
" (exists (u Int) (v Int) (and (>= u 0) (>= v 0) (= x (+ (* 7 u) (* 8 v))))))))");
|
||||
#endif
|
||||
|
||||
// Example from reciprocal mult: (2622 * x)>>16 = x/100 within a range.
|
||||
|
||||
|
||||
test_formula(l_true,
|
||||
"(forall (x Int) (y Int) "
|
||||
" (iff (exists (d Int) (= (+ x y) (* 2 d))) "
|
||||
" (iff (exists (d Int) (= x (* 2 d))) (exists (d Int) (= y (* 2 d))))))");
|
||||
|
||||
test_formula(l_true,
|
||||
"(forall (n Int) "
|
||||
" (implies (and (< 0 n) (< n 2400)) "
|
||||
" (or (and (<= n 2) (<= 2 (* 2 n))) "
|
||||
" (and (<= n 3) (<= 3 (* 2 n))) "
|
||||
" (and (<= n 5) (<= 5 (* 2 n))) "
|
||||
" (and (<= n 7) (<= 7 (* 2 n))) "
|
||||
" (and (<= n 13) (<= 13 (* 2 n))) "
|
||||
" (and (<= n 23) (<= 23 (* 2 n))) "
|
||||
" (and (<= n 43) (<= 43 (* 2 n))) "
|
||||
" (and (<= n 83) (<= 83 (* 2 n))) "
|
||||
" (and (<= n 163) (<= 163 (* 2 n))) "
|
||||
" (and (<= n 317) (<= 317 (* 2 n))) "
|
||||
" (and (<= n 631) (<= 631 (* 2 n))) "
|
||||
" (and (<= n 1259) (<= 1259 (* 2 n))) "
|
||||
" (and (<= n 2503) (<= 2503 (* 2 n)))))) ");
|
||||
|
||||
|
||||
|
||||
|
||||
memory::finalize();
|
||||
#ifdef _WINDOWS
|
||||
_CrtDumpMemoryLeaks();
|
||||
#endif
|
||||
exit(0);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -1,653 +0,0 @@
|
|||
/*++
|
||||
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();
|
||||
}
|
||||
|
|
@ -1,389 +0,0 @@
|
|||
/*++
|
||||
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();
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -1,45 +0,0 @@
|
|||
#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);
|
||||
|
||||
}
|
||||
File diff suppressed because it is too large
Load diff
|
|
@ -1,101 +0,0 @@
|
|||
#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);
|
||||
}
|
||||
|
|
@ -1,65 +0,0 @@
|
|||
/*++
|
||||
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();
|
||||
}
|
||||
|
||||
|
|
@ -1,42 +0,0 @@
|
|||
/*++
|
||||
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);
|
||||
}
|
||||
|
|
@ -1,89 +0,0 @@
|
|||
/*++
|
||||
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