mirror of
https://github.com/Z3Prover/z3
synced 2025-04-23 17:15:31 +00:00
minimizing smt 1.0 parser dependencies
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
This commit is contained in:
Leonardo de Moura
parent
95a25265f2
commit
87681c9e85
27 changed files with 0 additions and 623 deletions
|
|
@ -1,59 +0,0 @@
|
|||
/*++
|
||||
Copyright (c) 2006 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
tst_ast_pp.cpp
|
||||
|
||||
Abstract:
|
||||
|
||||
Test AST Pretty printing module
|
||||
|
||||
Author:
|
||||
|
||||
Nikolaj Bjorner (nbjorner) 2006-10-5
|
||||
|
||||
Revision History:
|
||||
|
||||
--*/
|
||||
#include "ast.h"
|
||||
#include "ast_pp.h"
|
||||
#include "ast_dag_pp.h"
|
||||
#include "smtparser.h"
|
||||
#include <iostream>
|
||||
|
||||
void tst_ast_pp()
|
||||
{
|
||||
ast_manager m;
|
||||
smtlib::parser* parser = smtlib::parser::create(m);
|
||||
|
||||
parser->initialize_smtlib();
|
||||
|
||||
|
||||
if (!parser->parse_string(
|
||||
"(benchmark test :extrasorts (A B) :extrafuns ((f A A) (g A A A) (x A) (p A bool)) \n"
|
||||
":formula (p (f x))\n"
|
||||
":extrafuns ((x1 Int) (y1 Int))\n"
|
||||
":formula (<= 1 (+ x1 y1))\n"
|
||||
":formula (let (x (g x x)) (let (x (g x x)) (let (x (g x x)) (let (x (g x x)) (p (g x x))))))\n"
|
||||
":formula (p x)\n"
|
||||
")")) {
|
||||
SASSERT(false);
|
||||
dealloc(parser);
|
||||
return;
|
||||
}
|
||||
|
||||
smtlib::benchmark* b = parser->get_benchmark();
|
||||
|
||||
for (unsigned j = 0; j < b->get_num_assumptions(); ++j) {
|
||||
expr* e = b->get_assumptions()[j];
|
||||
std::cout << mk_pp(e, m) << "\n";
|
||||
ast_dag_pp(std::cout, m, e);
|
||||
}
|
||||
for (unsigned j = 0; j < b->get_num_formulas(); ++j) {
|
||||
expr* e = b->begin_formulas()[j];
|
||||
std::cout << mk_pp(e, m) << "\n";
|
||||
ast_dag_pp(std::cout, m, e);
|
||||
}
|
||||
dealloc(parser);
|
||||
}
|
||||
|
|
@ -1,90 +0,0 @@
|
|||
/*++
|
||||
Copyright (c) 2008 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
tst_ast_smt_pp.cpp
|
||||
|
||||
Abstract:
|
||||
|
||||
Test AST Pretty printing module
|
||||
|
||||
Author:
|
||||
|
||||
Nikolaj Bjorner (nbjorner) 2008-09-04
|
||||
|
||||
Revision History:
|
||||
|
||||
--*/
|
||||
#include "ast.h"
|
||||
#include "ast_smt_pp.h"
|
||||
#include "smtparser.h"
|
||||
#include <iostream>
|
||||
#include <sstream>
|
||||
|
||||
void tst_ast_smt_pp()
|
||||
{
|
||||
ast_manager m;
|
||||
smtlib::parser* parser = smtlib::parser::create(m);
|
||||
|
||||
parser->initialize_smtlib();
|
||||
|
||||
|
||||
if (!parser->parse_string(
|
||||
"(benchmark test :extrasorts (A B) :extrafuns ((f A A) (g A A A) (x A) (p A bool)) \n"
|
||||
":extrafuns ((arg0 BitVec[8]) (arg1 BitVec[8]) (arg2 BitVec[8]))\n"
|
||||
":formula (p (f x))\n"
|
||||
":extrafuns ((x1 Int) (y1 Int))\n"
|
||||
":formula (<= 1 (+ x1 y1))\n"
|
||||
":formula (let (x (g x x)) (let (x (g x x)) (let (x (g x x)) (let (x (g x x)) (p (g x x))))))\n"
|
||||
":formula (p x)\n"
|
||||
":formula (bvsge (bvadd arg0 arg2) (extract[7:0] bv3[32]))\n"
|
||||
":formula (forall (x Int) (y Int) (z Int) (and (<= 1 x) (<= x y))) \n"
|
||||
":formula (forall (x Int) (y Int) (z Int) (and (<= 2 (ite (<= z 1) x (* 2 x))) (<= x y)))\n"
|
||||
":formula (forall (x Int) (y Int) (and (<= 2 (ite (forall (z Int) (<= z 1)) x (* 2 x))) (<= x y)))\n"
|
||||
":formula (forall (x Int) (y Int) (and (<= 2 (ite (forall (z Int) (or (> x y) (<= z 1))) x (* 2 x))) (<= x y)))\n"
|
||||
":extrafuns ((a1 Array))\n"
|
||||
":formula (= x1 (select (store a1 y1 y1) x1))\n"
|
||||
":extrafuns ((a2 Array[32:8]))\n"
|
||||
":formula (= arg0 (select a2 bv0[32]))\n"
|
||||
":datatypes ((list (cons (car Int) (cdr list)) nil))\n"
|
||||
":extrafuns ((a list) (b list) (c list))\n"
|
||||
":formula (is_nil nil)\n"
|
||||
":datatypes ((list1 (cons1 (car1 Int) (cdr1 list2)) nil1) (list2 (cons1 (car2 list) (cdr2 list1)) nil2) )\n"
|
||||
":formula (is_nil2 nil2)\n"
|
||||
")")) {
|
||||
SASSERT(false);
|
||||
dealloc(parser);
|
||||
return;
|
||||
}
|
||||
|
||||
smtlib::benchmark* b = parser->get_benchmark();
|
||||
|
||||
for (unsigned j = 0; j < b->get_num_formulas(); ++j) {
|
||||
expr* e = b->begin_formulas()[j];
|
||||
ast_smt_pp pp(m);
|
||||
pp.display(std::cout, e);
|
||||
}
|
||||
|
||||
|
||||
for (unsigned j = 0; j < b->get_num_formulas(); ++j) {
|
||||
expr* e = b->begin_formulas()[j];
|
||||
|
||||
// print and parse formula again.
|
||||
std::ostringstream buffer;
|
||||
ast_smt_pp pp(m);
|
||||
pp.display(buffer, e);
|
||||
ast_manager m2;
|
||||
smtlib::parser* parser2 = smtlib::parser::create(m2);
|
||||
parser2->initialize_smtlib();
|
||||
if (!parser2->parse_string(buffer.str().c_str())) {
|
||||
SASSERT(false);
|
||||
dealloc(parser2);
|
||||
return;
|
||||
}
|
||||
dealloc(parser2);
|
||||
}
|
||||
|
||||
|
||||
dealloc(parser);
|
||||
}
|
||||
42
src/test/dead/ackermanize.cpp
Normal file
42
src/test/dead/ackermanize.cpp
Normal file
|
|
@ -0,0 +1,42 @@
|
|||
#include "ackermanize.h"
|
||||
#include "smtparser.h"
|
||||
#include "ast_pp.h"
|
||||
|
||||
void tst_ackermanize()
|
||||
{
|
||||
ast_manager manager;
|
||||
|
||||
smtlib::parser* parser = smtlib::parser::create(manager);
|
||||
ackermanize ack(manager);
|
||||
|
||||
ast_ref<const_decl_ast> fD(manager);
|
||||
ast_ref<const_decl_ast> xD(manager);
|
||||
ast_ref<type_decl_ast> AD(manager);
|
||||
ast_ref<type_ast> A(manager);
|
||||
ast_ref<> a1(manager), a2(manager), a3(manager), a4(manager),
|
||||
a5(manager), a6(manager), a7(manager);
|
||||
ast_ref<> r(manager);
|
||||
|
||||
AD = manager.mk_type_decl(symbol("A"));
|
||||
A = manager.mk_type(AD.get());
|
||||
fD = manager.mk_const_decl(symbol("f"), A.get(), A.get(), A.get());
|
||||
a1 = manager.mk_const(manager.mk_const_decl(symbol("a1"), A.get()));
|
||||
a2 = manager.mk_const(manager.mk_const_decl(symbol("a2"), A.get()));
|
||||
a3 = manager.mk_const(manager.mk_const_decl(symbol("a3"), A.get()));
|
||||
a4 = manager.mk_const(manager.mk_const_decl(symbol("a4"), A.get()));
|
||||
a5 = manager.mk_const(manager.mk_const_decl(symbol("a5"), A.get()));
|
||||
a6 = manager.mk_const(manager.mk_const_decl(symbol("a6"), A.get()));
|
||||
a7 = manager.mk_const(manager.mk_const_decl(symbol("a7"), A.get()));
|
||||
|
||||
r = manager.mk_const(manager.get_basic_family_id(),
|
||||
OP_EQ,
|
||||
manager.mk_const(fD.get(), a1.get(), a2.get()),
|
||||
manager.mk_const(fD.get(), a2.get(), a3.get()));
|
||||
|
||||
TRACE("ackermanize", tout << mk_pp(r.get()) << std::endl;);
|
||||
|
||||
ack.reduce(r);
|
||||
|
||||
TRACE("ackermanize", tout << mk_pp(r.get()) << std::endl;);
|
||||
|
||||
}
|
||||
821
src/test/dead/core_theory.cpp
Normal file
821
src/test/dead/core_theory.cpp
Normal file
|
|
@ -0,0 +1,821 @@
|
|||
/*++
|
||||
Copyright (c) 2006 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
core_theory.cpp
|
||||
|
||||
Abstract:
|
||||
|
||||
Test core theory
|
||||
|
||||
Author:
|
||||
|
||||
Leonardo de Moura (leonardo) 2006-10-20.
|
||||
|
||||
Revision History:
|
||||
|
||||
--*/
|
||||
#include"core_theory.h"
|
||||
#include"theory_diff_logic.h"
|
||||
|
||||
class core_theory_tester {
|
||||
static void tst1() {
|
||||
core_theory t;
|
||||
t.m_params.m_relevancy_lvl = 2;
|
||||
|
||||
enode * n1 = t.mk_const();
|
||||
SASSERT(n1->check_invariant());
|
||||
enode * n2 = t.mk_const();
|
||||
SASSERT(n2->check_invariant());
|
||||
enode * app1 = t.mk_app_core(1, n1, n2);
|
||||
enode * app2 = t.mk_app_core(1, n2, n2);
|
||||
enode * app3 = t.mk_app_core(1, n1, n2);
|
||||
SASSERT(app1 != app2);
|
||||
SASSERT(app1 == app3);
|
||||
|
||||
literal l1 = t.mk_eq(n1, n2);
|
||||
literal l2 = t.mk_eq(n2, n1);
|
||||
literal l4 = t.mk_eq(n2, app1);
|
||||
SASSERT(l1 == l2);
|
||||
SASSERT(l1 != l4);
|
||||
|
||||
SASSERT(n1->get_root() != n2->get_root());
|
||||
|
||||
t.assert_lit(l1);
|
||||
t.assert_lit(l4);
|
||||
t.propagate();
|
||||
|
||||
SASSERT(n1->get_root() == n2->get_root());
|
||||
TRACE("core_theory", t.display(tout););
|
||||
}
|
||||
|
||||
static void tst2() {
|
||||
core_theory t;
|
||||
t.m_params.m_relevancy_lvl = 2;
|
||||
|
||||
enode * n1 = t.mk_const();
|
||||
enode * n2 = t.mk_const();
|
||||
enode * n3 = t.mk_const();
|
||||
|
||||
enode * a1 = t.mk_app_core(1, n1, n2);
|
||||
|
||||
literal l1 = t.mk_eq(n1, n2);
|
||||
t.assert_lit(l1);
|
||||
t.propagate();
|
||||
|
||||
t.push_scope();
|
||||
|
||||
literal l2 = t.mk_eq(n1, n3);
|
||||
t.assign(l2, mk_axiom());
|
||||
|
||||
enode * a2 = t.mk_app_core(1, n1, n1);
|
||||
enode * a3 = t.mk_app_core(1, n1, n3);
|
||||
|
||||
TRACE("core_theory", t.display(tout););
|
||||
|
||||
t.propagate();
|
||||
SASSERT(t.is_equal(a1, a2));
|
||||
SASSERT(!t.is_equal(a1, a3));
|
||||
t.m_sat->mark_as_relevant(l2.var());
|
||||
t.propagate();
|
||||
SASSERT(t.is_equal(a1, a2));
|
||||
SASSERT(t.is_equal(a1, a3));
|
||||
|
||||
t.pop_scope(1);
|
||||
|
||||
t.propagate();
|
||||
SASSERT(to_app(a1)->get_cg() == a1);
|
||||
TRACE("core_theory", t.display(tout););
|
||||
}
|
||||
|
||||
static void tst3() {
|
||||
core_theory t;
|
||||
t.m_params.m_relevancy_lvl = 0;
|
||||
|
||||
enode * n1 = t.mk_const();
|
||||
enode * n2 = t.mk_const();
|
||||
enode * n3 = t.mk_const();
|
||||
|
||||
enode * a1 = t.mk_app_core(1, n1, n2);
|
||||
|
||||
literal l1 = t.mk_eq(n1, n2);
|
||||
t.assert_lit(l1);
|
||||
t.propagate();
|
||||
|
||||
t.push_scope();
|
||||
|
||||
literal l2 = t.mk_eq(n1, n3);
|
||||
t.assign(l2, mk_axiom());
|
||||
|
||||
enode * a2 = t.mk_app_core(1, n1, n1);
|
||||
enode * a3 = t.mk_app_core(1, n1, n3);
|
||||
|
||||
TRACE("core_theory", t.display(tout););
|
||||
|
||||
t.propagate();
|
||||
SASSERT(t.is_equal(a1, a2));
|
||||
SASSERT(t.is_equal(a1, a3));
|
||||
|
||||
t.pop_scope(1);
|
||||
|
||||
t.propagate();
|
||||
SASSERT(to_app(a1)->get_cg() == a1);
|
||||
TRACE("core_theory", t.display(tout););
|
||||
}
|
||||
|
||||
static void tst8() {
|
||||
core_theory t;
|
||||
t.m_params.m_relevancy_lvl = 2;
|
||||
|
||||
enode * n1 = t.mk_const();
|
||||
enode * n2 = t.mk_const();
|
||||
enode * n3 = t.mk_const();
|
||||
enode * n4 = t.mk_const();
|
||||
enode * n5 = t.mk_const();
|
||||
enode * n6 = t.mk_const();
|
||||
|
||||
t.push_scope();
|
||||
|
||||
t.assert_lit(~t.mk_eq(n1, n2));
|
||||
t.assert_lit(t.mk_eq(n1, n3));
|
||||
t.assert_lit(t.mk_eq(n2, n4));
|
||||
t.assert_lit(t.mk_eq(n3, n6));
|
||||
t.assert_lit(t.mk_eq(n1, n5));
|
||||
t.propagate();
|
||||
|
||||
SASSERT(!t.inconsistent());
|
||||
|
||||
t.assert_lit(t.mk_eq(n3, n4));
|
||||
TRACE("core_theory", t.display(tout););
|
||||
t.propagate();
|
||||
|
||||
SASSERT(t.inconsistent());
|
||||
|
||||
t.pop_scope(1);
|
||||
}
|
||||
|
||||
static void tst9() {
|
||||
TRACE("core_theory", tout << "tst9\n";);
|
||||
core_theory t;
|
||||
t.m_params.m_relevancy_lvl = 2;
|
||||
|
||||
t.push_scope();
|
||||
enode * n = t.mk_const();
|
||||
unsigned id = n->get_id();
|
||||
t.pop_scope(1);
|
||||
TRACE("core_theory", tout << "after pop\n";);
|
||||
n = t.mk_const();
|
||||
SASSERT(id == n->get_id());
|
||||
TRACE("core_theory", tout << "end of tst9\n";);
|
||||
}
|
||||
|
||||
static void tst10() {
|
||||
TRACE("core_theory", tout << "tst10\n";);
|
||||
core_theory t;
|
||||
t.m_params.m_relevancy_lvl = 2;
|
||||
|
||||
t.push_scope();
|
||||
enode * n = t.mk_const();
|
||||
unsigned id = n->get_id();
|
||||
t.inc_weak_ref(id);
|
||||
t.pop_scope(1);
|
||||
TRACE("core_theory", tout << "after pop\n";);
|
||||
n = t.mk_const();
|
||||
SASSERT(id + 1 == n->get_id());
|
||||
t.dec_weak_ref(id);
|
||||
n = t.mk_const();
|
||||
SASSERT(id = n->get_id());
|
||||
TRACE("core_theory", tout << "end of tst10\n";);
|
||||
}
|
||||
|
||||
static void tst11() {
|
||||
core_theory t;
|
||||
t.m_params.m_relevancy_lvl = 2;
|
||||
|
||||
enode * n1 = t.mk_const();
|
||||
enode * n2 = t.mk_const();
|
||||
t.add_eq(n1, n2, proto_eq_proof::mk_axiom());
|
||||
enode * f1 = t.mk_app_core(1, n1);
|
||||
enode * f2 = t.mk_app_core(1, n2);
|
||||
t.propagate();
|
||||
SASSERT(t.is_equal(f1, f2));
|
||||
t.push_scope();
|
||||
literal l1 = t.mk_lit();
|
||||
literal l2 = t.mk_eq(f1, f2);
|
||||
t.mk_main_clause(l1, l2);
|
||||
SASSERT(t.get_assignment(l2) == l_true);
|
||||
t.pop_scope(1);
|
||||
SASSERT(t.get_assignment(l2) == l_true);
|
||||
}
|
||||
|
||||
static void tst12() {
|
||||
core_theory t;
|
||||
t.m_params.m_relevancy_lvl = 2;
|
||||
|
||||
enode * n1 = t.mk_const();
|
||||
enode * n2 = t.mk_const();
|
||||
t.add_diseq(n1, n2, proto_diseq_proof::mk_axiom());
|
||||
enode * n3 = t.mk_const();
|
||||
enode * n4 = t.mk_const();
|
||||
t.add_eq(n1, n3, proto_eq_proof::mk_axiom());
|
||||
t.add_eq(n2, n4, proto_eq_proof::mk_axiom());
|
||||
t.propagate();
|
||||
SASSERT(t.is_diseq(n3, n4));
|
||||
t.push_scope();
|
||||
literal l1 = t.mk_lit();
|
||||
literal l2 = t.mk_eq(n3, n4);
|
||||
t.mk_main_clause(l1, l2);
|
||||
SASSERT(t.get_assignment(l2) == l_false);
|
||||
t.pop_scope(1);
|
||||
SASSERT(t.get_assignment(l2) == l_false);
|
||||
}
|
||||
|
||||
static void tst13() {
|
||||
core_theory t;
|
||||
t.m_params.m_relevancy_lvl = 2;
|
||||
|
||||
enode * n1 = t.mk_const();
|
||||
enode * n2 = t.mk_const();
|
||||
enode * n3 = t.mk_const();
|
||||
enode * n4 = t.mk_app_core(1, n1);
|
||||
enode * n5 = t.mk_app_core(1, n4);
|
||||
enode * n6 = t.mk_app_core(1, n3);
|
||||
enode * n7 = t.mk_app_core(1, n6);
|
||||
|
||||
SASSERT(!t.is_relevant(n1));
|
||||
SASSERT(!t.is_relevant(n2));
|
||||
SASSERT(!t.is_relevant(n3));
|
||||
SASSERT(!t.is_relevant(n4));
|
||||
SASSERT(!t.is_relevant(n5));
|
||||
SASSERT(!t.is_relevant(n6));
|
||||
SASSERT(!t.is_relevant(n7));
|
||||
|
||||
t.add_eq(n6, n1, proto_eq_proof::mk_axiom());
|
||||
|
||||
SASSERT(!t.is_relevant(n1));
|
||||
SASSERT(!t.is_relevant(n2));
|
||||
SASSERT(!t.is_relevant(n3));
|
||||
SASSERT(!t.is_relevant(n4));
|
||||
SASSERT(!t.is_relevant(n5));
|
||||
SASSERT(!t.is_relevant(n6));
|
||||
SASSERT(!t.is_relevant(n7));
|
||||
|
||||
t.push_scope();
|
||||
|
||||
t.assert_lit(t.mk_eq(n7,n2));
|
||||
t.propagate();
|
||||
SASSERT(t.is_equal(n7, n2));
|
||||
|
||||
SASSERT(t.is_relevant(n1));
|
||||
SASSERT(t.is_relevant(n2));
|
||||
SASSERT(t.is_relevant(n3));
|
||||
SASSERT(t.is_relevant(n4));
|
||||
SASSERT(!t.is_relevant(n5));
|
||||
SASSERT(t.is_relevant(n6));
|
||||
SASSERT(t.is_relevant(n7));
|
||||
|
||||
t.pop_scope(1);
|
||||
|
||||
SASSERT(!t.is_relevant(n1));
|
||||
SASSERT(!t.is_relevant(n2));
|
||||
SASSERT(!t.is_relevant(n3));
|
||||
SASSERT(!t.is_relevant(n4));
|
||||
SASSERT(!t.is_relevant(n5));
|
||||
SASSERT(!t.is_relevant(n6));
|
||||
SASSERT(!t.is_relevant(n7));
|
||||
}
|
||||
|
||||
static void tst14() {
|
||||
core_theory t;
|
||||
t.m_params.m_relevancy_lvl = 2;
|
||||
|
||||
enode * n1 = t.mk_const();
|
||||
enode * n2 = t.mk_const();
|
||||
enode * n3 = t.mk_const();
|
||||
enode * n4 = t.mk_app_core(1, n1);
|
||||
enode * n5 = t.mk_app_core(1, n4);
|
||||
enode * n6 = t.mk_app_core(1, n3);
|
||||
enode * n7 = t.mk_app_core(1, n6);
|
||||
|
||||
t.assert_lit(t.mk_eq(n1,n2));
|
||||
t.propagate();
|
||||
|
||||
SASSERT(t.is_relevant(n1));
|
||||
SASSERT(t.is_relevant(n2));
|
||||
SASSERT(!t.is_relevant(n3));
|
||||
SASSERT(!t.is_relevant(n4));
|
||||
SASSERT(!t.is_relevant(n5));
|
||||
SASSERT(!t.is_relevant(n6));
|
||||
SASSERT(!t.is_relevant(n7));
|
||||
|
||||
t.push_scope();
|
||||
t.assign_eq(n2, n3, proto_eq_proof::mk_axiom());
|
||||
t.propagate();
|
||||
|
||||
SASSERT(t.is_relevant(n1));
|
||||
SASSERT(t.is_relevant(n2));
|
||||
SASSERT(t.is_relevant(n3));
|
||||
SASSERT(!t.is_relevant(n4));
|
||||
SASSERT(!t.is_relevant(n5));
|
||||
SASSERT(!t.is_relevant(n6));
|
||||
SASSERT(!t.is_relevant(n7));
|
||||
|
||||
t.pop_scope(1);
|
||||
|
||||
SASSERT(t.is_relevant(n1));
|
||||
SASSERT(t.is_relevant(n2));
|
||||
SASSERT(!t.is_relevant(n3));
|
||||
SASSERT(!t.is_relevant(n4));
|
||||
SASSERT(!t.is_relevant(n5));
|
||||
SASSERT(!t.is_relevant(n6));
|
||||
SASSERT(!t.is_relevant(n7));
|
||||
|
||||
t.push_scope();
|
||||
t.assign_eq(n2, n7, proto_eq_proof::mk_axiom());
|
||||
t.propagate();
|
||||
|
||||
SASSERT(t.is_relevant(n1));
|
||||
SASSERT(t.is_relevant(n2));
|
||||
SASSERT(t.is_relevant(n3));
|
||||
SASSERT(!t.is_relevant(n4));
|
||||
SASSERT(!t.is_relevant(n5));
|
||||
SASSERT(t.is_relevant(n6));
|
||||
SASSERT(t.is_relevant(n7));
|
||||
|
||||
t.pop_scope(1);
|
||||
|
||||
SASSERT(t.is_relevant(n1));
|
||||
SASSERT(t.is_relevant(n2));
|
||||
SASSERT(!t.is_relevant(n3));
|
||||
SASSERT(!t.is_relevant(n4));
|
||||
SASSERT(!t.is_relevant(n5));
|
||||
SASSERT(!t.is_relevant(n6));
|
||||
SASSERT(!t.is_relevant(n7));
|
||||
}
|
||||
|
||||
static void tst15() {
|
||||
core_theory t;
|
||||
t.m_params.m_relevancy_lvl = 0;
|
||||
|
||||
literal l1 = t.mk_lit();
|
||||
literal l2 = t.mk_lit();
|
||||
literal l3 = t.mk_lit();
|
||||
literal l4 = t.mk_lit();
|
||||
|
||||
t.push_scope();
|
||||
t.assign(l1, mk_axiom());
|
||||
t.push_scope();
|
||||
|
||||
enode * n1 = t.mk_const();
|
||||
enode * n2 = t.mk_const();
|
||||
enode * a1 = t.mk_app_core(1, n1);
|
||||
enode * a2 = t.mk_app_core(1, n2);
|
||||
enode * n3 = t.mk_const();
|
||||
enode * n4 = t.mk_const();
|
||||
|
||||
literal eq1 = t.mk_eq(a1, n3);
|
||||
t.assign(eq1, mk_axiom());
|
||||
|
||||
t.push_scope();
|
||||
literal eq2 = t.mk_eq(a2, n4);
|
||||
t.assign(eq2, mk_axiom());
|
||||
|
||||
TRACE("core_theory", tout << "eq1: " << eq1 << ", eq2: " << eq2 << "\n";);
|
||||
|
||||
t.mk_transient_clause(~eq2, l3);
|
||||
t.mk_transient_clause(~eq2, l4);
|
||||
t.mk_transient_clause(~eq1, l2);
|
||||
literal_vector lits;
|
||||
lits.push_back(~l4); lits.push_back(~l3); lits.push_back(~l2); lits.push_back(~l1);
|
||||
t.mk_transient_clause(lits);
|
||||
SASSERT(t.inconsistent());
|
||||
#ifdef Z3DEBUG
|
||||
bool r =
|
||||
#endif
|
||||
t.m_sat->resolve_conflict();
|
||||
SASSERT(r);
|
||||
SASSERT(t.m_sat->m_scope_lvl == 2);
|
||||
SASSERT(t.m_sat->m_ref_count[eq1.var()] > 0);
|
||||
SASSERT(t.m_sat->m_ref_count[eq2.var()] > 0);
|
||||
t.pop_scope(2);
|
||||
SASSERT(n1->get_ref_count() > 0);
|
||||
SASSERT(n2->get_ref_count() > 0);
|
||||
SASSERT(a1->get_ref_count() > 0);
|
||||
SASSERT(a2->get_ref_count() > 0);
|
||||
t.push_scope();
|
||||
literal eq3 = t.mk_eq(n1, n2);
|
||||
t.assign(eq3, mk_axiom());
|
||||
t.propagate();
|
||||
TRACE("core_theory", t.display(tout););
|
||||
SASSERT(a1->get_root() == a2->get_root());
|
||||
#ifdef Z3DEBUG
|
||||
t.m_sat->del_learned_clauses();
|
||||
#endif
|
||||
t.pop_scope(1);
|
||||
}
|
||||
|
||||
static void tst16(bool use_relevancy) {
|
||||
core_theory t;
|
||||
t.m_params.m_relevancy_lvl = use_relevancy ? 2 : 0;
|
||||
|
||||
literal l0 = t.mk_lit();
|
||||
literal l1 = t.mk_lit();
|
||||
literal l2 = t.mk_lit();
|
||||
literal l3 = t.mk_lit();
|
||||
literal l4 = t.mk_lit();
|
||||
|
||||
|
||||
enode * n1 = t.mk_const();
|
||||
enode * n2 = t.mk_const();
|
||||
enode * n3 = t.mk_const();
|
||||
enode * n4 = t.mk_app_core(1, n1);
|
||||
|
||||
t.push_scope();
|
||||
t.assign(l0, mk_axiom());
|
||||
|
||||
t.push_scope();
|
||||
t.assign(l1, mk_axiom());
|
||||
|
||||
t.push_scope();
|
||||
enode * n5 = t.mk_app_core(1, n2);
|
||||
enode * n6 = t.mk_const();
|
||||
literal eq1 = t.mk_eq(n5, n6);
|
||||
t.assign(eq1, mk_axiom());
|
||||
t.mk_transient_clause(~l1, l2);
|
||||
t.mk_transient_clause(~eq1, l3);
|
||||
t.mk_transient_clause(~eq1, l4);
|
||||
literal_vector lits;
|
||||
lits.push_back(~l4); lits.push_back(~l3); lits.push_back(~l2);
|
||||
t.mk_transient_clause(lits);
|
||||
SASSERT(t.inconsistent());
|
||||
#ifdef Z3DEBUG
|
||||
bool r =
|
||||
#endif
|
||||
t.m_sat->resolve_conflict();
|
||||
SASSERT(r);
|
||||
t.propagate();
|
||||
SASSERT(t.m_sat->m_scope_lvl == 2);
|
||||
SASSERT(t.m_sat->m_ref_count[eq1.var()] > 0);
|
||||
SASSERT(t.m_sat->get_assignment(eq1) == l_false);
|
||||
|
||||
t.pop_scope(1);
|
||||
SASSERT(t.m_sat->m_scope_lvl == 1);
|
||||
SASSERT(t.m_sat->m_ref_count[eq1.var()] > 0);
|
||||
SASSERT(t.m_sat->get_assignment(eq1) == l_undef);
|
||||
|
||||
t.push_scope();
|
||||
SASSERT(n5->get_ref_count() == 1);
|
||||
t.add_eq(n1, n2, proto_eq_proof::mk_axiom());
|
||||
SASSERT(to_app(n4)->get_cg() == n5);
|
||||
if (use_relevancy) {
|
||||
t.mark_as_relevant(n5);
|
||||
}
|
||||
SASSERT(!use_relevancy || n5->get_ref_count() == 3);
|
||||
SASSERT(use_relevancy || n5->get_ref_count() == 2);
|
||||
SASSERT(n5->get_root() != n4->get_root());
|
||||
SASSERT(!use_relevancy || t.is_relevant(n5));
|
||||
t.propagate();
|
||||
SASSERT(n5->get_root() == n4->get_root());
|
||||
SASSERT(!use_relevancy || n5->get_ref_count() == 4);
|
||||
SASSERT(use_relevancy || n5->get_ref_count() == 3);
|
||||
#ifdef Z3DEBUG
|
||||
t.m_sat->del_learned_clauses();
|
||||
#endif
|
||||
SASSERT(!use_relevancy || n5->get_ref_count() == 3);
|
||||
SASSERT(use_relevancy || n5->get_ref_count() == 2);
|
||||
|
||||
SASSERT(t.m_sat->m_ref_count[eq1.var()] == 0);
|
||||
|
||||
t.pop_scope(1);
|
||||
}
|
||||
|
||||
static void tst17() {
|
||||
theory_idl idl;
|
||||
core_theory t;
|
||||
t.m_params.m_relevancy_lvl = 0;
|
||||
|
||||
t.add_theory(&idl);
|
||||
|
||||
literal l0 = t.mk_lit();
|
||||
literal l1 = t.mk_lit();
|
||||
literal l2 = t.mk_lit();
|
||||
literal l3 = t.mk_lit();
|
||||
literal l4 = t.mk_lit();
|
||||
enode * n1 = t.mk_const();
|
||||
|
||||
t.push_scope();
|
||||
t.assign(l0, mk_axiom());
|
||||
|
||||
t.push_scope();
|
||||
t.assign(l1, mk_axiom());
|
||||
|
||||
t.push_scope();
|
||||
enode * n2 = idl.mk_offset(n1, rational(1));
|
||||
enode * n3 = t.mk_const();
|
||||
literal eq1 = t.mk_eq(n2, n3);
|
||||
t.assign(eq1, mk_axiom());
|
||||
t.mk_transient_clause(~l1, l2);
|
||||
t.mk_transient_clause(~eq1, l3);
|
||||
t.mk_transient_clause(~eq1, l4);
|
||||
literal_vector lits;
|
||||
lits.push_back(~l4); lits.push_back(~l3); lits.push_back(~l2);
|
||||
t.mk_transient_clause(lits);
|
||||
SASSERT(t.inconsistent());
|
||||
#ifdef Z3DEBUG
|
||||
bool r =
|
||||
#endif
|
||||
t.m_sat->resolve_conflict();
|
||||
SASSERT(r);
|
||||
t.propagate();
|
||||
SASSERT(t.m_sat->m_scope_lvl == 2);
|
||||
SASSERT(t.m_sat->m_ref_count[eq1.var()] > 0);
|
||||
SASSERT(t.m_sat->get_assignment(eq1) == l_false);
|
||||
|
||||
t.pop_scope(1);
|
||||
SASSERT(t.m_sat->m_scope_lvl == 1);
|
||||
SASSERT(t.m_sat->m_ref_count[eq1.var()] > 0);
|
||||
SASSERT(t.m_sat->get_assignment(eq1) == l_undef);
|
||||
SASSERT(n2->get_ref_count() == 1);
|
||||
unsigned n2_id = n2->get_id();
|
||||
|
||||
// n2 is still alive
|
||||
#ifdef Z3DEBUG
|
||||
t.m_sat->del_learned_clauses();
|
||||
#endif
|
||||
// n2 is dead
|
||||
SASSERT(t.m_enodes[n2_id] == 0);
|
||||
// n2_id cannot be reused since its weak_counter > 0
|
||||
// SASSERT(t.m_weak_counters[n2_id] > 0);
|
||||
|
||||
enode * n4 = idl.mk_offset(n1, rational(1));
|
||||
SASSERT(n4->get_id() != n2_id);
|
||||
SASSERT(n4->get_id() < static_cast<unsigned>(t.m_next_id));
|
||||
}
|
||||
|
||||
static void tst18() {
|
||||
core_theory t;
|
||||
|
||||
enode * n1 = t.mk_const();
|
||||
enode * n2 = t.mk_const();
|
||||
enode * n3 = t.mk_const();
|
||||
|
||||
enode * a1 = t.mk_app_core(1, n1, n2);
|
||||
|
||||
literal l1 = t.mk_eq(n1, n3);
|
||||
t.assert_lit(l1);
|
||||
t.propagate();
|
||||
|
||||
enode * args[2] = { n3, n2 };
|
||||
|
||||
SASSERT(t.get_enode_eq_to_app(1, 2, args) != 0);
|
||||
SASSERT(a1->get_root() == t.get_enode_eq_to_app(1, 2, args)->get_root());
|
||||
}
|
||||
|
||||
static void tst19() {
|
||||
core_theory t;
|
||||
t.m_params.m_relevancy_lvl = 0;
|
||||
|
||||
enode * n1 = t.mk_const();
|
||||
enode * n2 = t.mk_const();
|
||||
enode * n3 = t.mk_const();
|
||||
|
||||
literal l1 = t.mk_eq(n1, n2);
|
||||
literal l2 = t.mk_eq(n2, n3);
|
||||
literal l3 = t.mk_eq(n1, n3);
|
||||
|
||||
enode * n4 = t.mk_const();
|
||||
enode * n5 = t.mk_const();
|
||||
enode * n6 = t.mk_const();
|
||||
enode * n7 = t.mk_const();
|
||||
|
||||
literal l4 = t.mk_eq(n4, n5);
|
||||
literal l5 = t.mk_eq(n6, n7);
|
||||
literal l6 = t.mk_eq(n5, n7);
|
||||
literal l7 = t.mk_eq(n4, n6);
|
||||
|
||||
t.mk_main_clause(l3, l7);
|
||||
|
||||
t.push_scope();
|
||||
t.assign(l1, mk_axiom());
|
||||
t.assign(~l2, mk_axiom());
|
||||
t.assign(l4, mk_axiom());
|
||||
t.assign(l5, mk_axiom());
|
||||
t.assign(~l6, mk_axiom());
|
||||
t.propagate();
|
||||
SASSERT(t.inconsistent());
|
||||
t.m_sat->resolve_conflict();
|
||||
}
|
||||
|
||||
static void tst20() {
|
||||
theory_idl idl;
|
||||
core_theory t;
|
||||
t.m_params.m_relevancy_lvl = 0;
|
||||
|
||||
t.add_theory(&idl);
|
||||
|
||||
enode * n1 = t.mk_const();
|
||||
enode * n2 = idl.mk_offset(n1, rational(1));
|
||||
enode * n3 = idl.mk_offset(n2, rational(1));
|
||||
enode * n4 = idl.mk_offset(n1, rational(2));
|
||||
SASSERT(n4 == n3);
|
||||
|
||||
enode * r1 = idl.mk_num(rational(1));
|
||||
enode * r2 = idl.mk_offset(r1, rational(1));
|
||||
enode * r3 = idl.mk_num(rational(2));
|
||||
SASSERT(r2 == r3);
|
||||
}
|
||||
|
||||
static void tst21() {
|
||||
enable_debug("add_eq");
|
||||
enable_debug("core_invariant");
|
||||
theory_idl idl;
|
||||
core_theory t;
|
||||
t.m_params.m_relevancy_lvl = 0;
|
||||
t.add_theory(&idl);
|
||||
theory_id idl_id = idl.get_id();
|
||||
|
||||
enode * n1 = t.mk_const();
|
||||
enode * n2 = t.mk_const();
|
||||
enode * n3 = t.mk_const();
|
||||
enode * n4 = t.mk_const();
|
||||
enode * n5 = t.mk_const();
|
||||
literal l1 = t.mk_eq(n1, n2);
|
||||
literal l2 = t.mk_eq(n1, n3);
|
||||
literal l3 = t.mk_eq(n4, n5);
|
||||
literal l4 = t.mk_eq(n4, n3);
|
||||
|
||||
t.push_scope();
|
||||
t.assign(l1, mk_axiom());
|
||||
t.propagate();
|
||||
SASSERT(n2->get_root() == n2);
|
||||
t.push_scope();
|
||||
t.assign(l2, mk_axiom());
|
||||
t.propagate();
|
||||
t.push_scope();
|
||||
t.assign(l3, mk_axiom());
|
||||
t.propagate();
|
||||
SASSERT(n5->get_root() == n5);
|
||||
SASSERT(n4->get_root() == n5);
|
||||
t.push_scope();
|
||||
t.assign(l4, mk_axiom());
|
||||
t.propagate();
|
||||
SASSERT(n2->get_root() == n2);
|
||||
enode * o1 = idl.mk_offset(n4, rational(1));
|
||||
SASSERT(n4->get_th_var(idl_id) != null_theory_var);
|
||||
SASSERT(n2->get_th_var(idl_id) == n4->get_th_var(idl_id));
|
||||
t.pop_scope(1);
|
||||
SASSERT(n4->get_th_var(idl_id) != null_theory_var);
|
||||
SASSERT(n5->get_th_var(idl_id) == n4->get_th_var(idl_id));
|
||||
SASSERT(n2->get_th_var(idl_id) == null_theory_var);
|
||||
t.pop_scope(1);
|
||||
SASSERT(n4->get_th_var(idl.get_id()) != null_theory_var);
|
||||
SASSERT(n5->get_th_var(idl_id) == null_theory_var);
|
||||
SASSERT(n2->get_th_var(idl_id) == null_theory_var);
|
||||
}
|
||||
|
||||
static void tst22() {
|
||||
enable_debug("add_eq");
|
||||
enable_debug("core_invariant");
|
||||
theory_idl idl;
|
||||
core_theory t;
|
||||
t.m_params.m_relevancy_lvl = 0;
|
||||
t.add_theory(&idl);
|
||||
theory_id idl_id = idl.get_id();
|
||||
|
||||
enode * n1 = t.mk_const();
|
||||
enode * n2 = t.mk_const();
|
||||
enode * n3 = t.mk_const();
|
||||
enode * n4 = t.mk_const();
|
||||
enode * n5 = t.mk_const();
|
||||
enode * o1 = idl.mk_offset(n2, rational(1));
|
||||
literal l1 = t.mk_eq(n1, n2);
|
||||
literal l2 = t.mk_eq(n1, n3);
|
||||
literal l3 = t.mk_eq(n4, n5);
|
||||
literal l4 = t.mk_eq(n4, n3);
|
||||
|
||||
t.push_scope();
|
||||
t.assign(l1, mk_axiom());
|
||||
t.propagate();
|
||||
SASSERT(n2->get_root() == n2);
|
||||
|
||||
t.push_scope();
|
||||
t.assign(l2, mk_axiom());
|
||||
t.propagate();
|
||||
|
||||
t.push_scope();
|
||||
t.assign(l3, mk_axiom());
|
||||
t.propagate();
|
||||
SASSERT(n5->get_root() == n5);
|
||||
SASSERT(n4->get_root() == n5);
|
||||
|
||||
t.push_scope();
|
||||
t.assign(l4, mk_axiom());
|
||||
t.propagate();
|
||||
SASSERT(n2->get_root() == n2);
|
||||
enode * o2 = idl.mk_offset(n4, rational(1));
|
||||
SASSERT(n4->get_th_var(idl_id) != null_theory_var);
|
||||
SASSERT(n2->get_th_var(idl_id) != null_theory_var);
|
||||
SASSERT(n2->get_th_var(idl_id) != n4->get_th_var(idl_id));
|
||||
|
||||
t.pop_scope(1);
|
||||
SASSERT(n2->get_th_var(idl_id) != null_theory_var);
|
||||
SASSERT(n4->get_th_var(idl_id) != null_theory_var);
|
||||
SASSERT(n4->get_th_var(idl_id) == n5->get_th_var(idl_id));
|
||||
|
||||
t.pop_scope(1);
|
||||
SASSERT(n2->get_th_var(idl_id) != null_theory_var);
|
||||
SASSERT(n4->get_th_var(idl_id) != null_theory_var);
|
||||
SASSERT(n5->get_th_var(idl_id) == null_theory_var);
|
||||
}
|
||||
|
||||
static void tst23() {
|
||||
core_theory t;
|
||||
t.m_params.m_relevancy_lvl = 0;
|
||||
enable_trace("th_diseq_prop_bug");
|
||||
enable_trace("add_eq");
|
||||
|
||||
enode * n1 = t.mk_const();
|
||||
enode * n2 = t.mk_true_term();
|
||||
enode * d[2] = {n1, n2};
|
||||
t.assert_distinct_class(2, d);
|
||||
enode * n3 = t.mk_const();
|
||||
enode * n4 = t.mk_const();
|
||||
|
||||
literal l1 = t.mk_eq(n3, n4);
|
||||
literal l2 = t.mk_eq(n4, n1);
|
||||
literal l3 = t.mk_eq(n3, n2);
|
||||
t.push_scope();
|
||||
t.assign(l1, mk_axiom());
|
||||
t.propagate();
|
||||
SASSERT(n3->get_root() == n4->get_root());
|
||||
t.push_scope();
|
||||
t.assign(l2, mk_axiom());
|
||||
t.propagate();
|
||||
SASSERT(n3->get_root() == n1->get_root());
|
||||
SASSERT(t.is_diseq(n3, n2));
|
||||
SASSERT(t.get_assignment(l3) == l_false);
|
||||
SASSERT(t.m_sat->m_explanation[l3.var()].kind() == EXPL_EXT);
|
||||
literal_vector antecedents;
|
||||
t.get_antecedents(~l3, t.m_sat->m_explanation[l3.var()].obj(), antecedents);
|
||||
}
|
||||
|
||||
public:
|
||||
static void run_tests() {
|
||||
tst1();
|
||||
tst2();
|
||||
tst3();
|
||||
tst8();
|
||||
tst9();
|
||||
tst10();
|
||||
tst11();
|
||||
tst12();
|
||||
tst13();
|
||||
tst14();
|
||||
tst15();
|
||||
tst16(false);
|
||||
tst16(true);
|
||||
tst17();
|
||||
tst18();
|
||||
tst19();
|
||||
tst20();
|
||||
tst21();
|
||||
tst22();
|
||||
tst23();
|
||||
}
|
||||
};
|
||||
|
||||
struct foo {
|
||||
bool_var m_var; // boolean variable associated with the equation
|
||||
enode * m_lhs;
|
||||
enode * m_rhs;
|
||||
};
|
||||
|
||||
struct bar {
|
||||
bool m_v1:1;
|
||||
bool m_v2:1;
|
||||
bool m_v3:1;
|
||||
bool m_v4:1;
|
||||
bool m_v5:1;
|
||||
bool m_v6:1;
|
||||
bool m_v7:1;
|
||||
bool m_v8:1;
|
||||
};
|
||||
|
||||
struct bar2 {
|
||||
bool m_v1:1;
|
||||
bool m_v2:1;
|
||||
unsigned m_val:30;
|
||||
};
|
||||
|
||||
void tst_core_theory() {
|
||||
TRACE("core_theory", tout << "sizeof(equation): " << sizeof(equation) << "\n";);
|
||||
TRACE("core_theory", tout << "sizeof(foo): " << sizeof(foo) << "\n";);
|
||||
TRACE("core_theory", tout << "sizeof(bar): " << sizeof(bar) << "\n";);
|
||||
TRACE("core_theory", tout << "sizeof(bar2): " << sizeof(bar2) << "\n";);
|
||||
TRACE("core_theory", tout << "sizeof(theory_var_list): " << sizeof(theory_var_list) << "\n";);
|
||||
TRACE("core_theory", tout << "sizeof(enode): " << sizeof(enode) << "\n";);
|
||||
enable_debug("cg_bug");
|
||||
core_theory_tester::run_tests();
|
||||
}
|
||||
|
||||
75
src/test/dead/dimacs.cpp
Normal file
75
src/test/dead/dimacs.cpp
Normal file
|
|
@ -0,0 +1,75 @@
|
|||
/*++
|
||||
Copyright (c) 2006 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
tst_dimacs.cpp
|
||||
|
||||
Abstract:
|
||||
|
||||
Test dimacs parser
|
||||
|
||||
Author:
|
||||
|
||||
Leonardo de Moura (leonardo) 2006-10-02.
|
||||
|
||||
Revision History:
|
||||
|
||||
--*/
|
||||
|
||||
#include <iostream>
|
||||
#include <fstream>
|
||||
#ifdef _WINDOWS
|
||||
#include <windows.h>
|
||||
#include <strsafe.h>
|
||||
#endif
|
||||
#include"trace.h"
|
||||
#include"dimacs_parser.h"
|
||||
|
||||
class dummy_sat {
|
||||
unsigned m_num_vars;
|
||||
public:
|
||||
dummy_sat():m_num_vars(0) {}
|
||||
unsigned get_num_vars() {
|
||||
return m_num_vars;
|
||||
}
|
||||
void mk_var() {
|
||||
TRACE("dimacs", tout << "making variable: p" << m_num_vars << "\n";);
|
||||
m_num_vars++;
|
||||
}
|
||||
void mk_clause(literal_vector & lits) {
|
||||
TRACE("dimacs", tout << "making clause: " << lits << "\n";);
|
||||
}
|
||||
};
|
||||
|
||||
static void tst1()
|
||||
{
|
||||
#ifdef _WINDOWS
|
||||
dummy_sat solver;
|
||||
const char * base = ".";
|
||||
std::string pattern(base);
|
||||
pattern += "\\*.cnf";
|
||||
|
||||
char buffer[MAX_PATH];
|
||||
|
||||
WIN32_FIND_DATAA data;
|
||||
HANDLE h = FindFirstFileA(pattern.c_str(),&data);
|
||||
|
||||
while (h != INVALID_HANDLE_VALUE) {
|
||||
StringCchPrintfA(buffer, ARRAYSIZE(buffer), "%s\\%s", base, data.cFileName);
|
||||
|
||||
TRACE("dimacs", tout << "Parsing: " << buffer << "\n";);
|
||||
|
||||
std::ifstream s(buffer);
|
||||
|
||||
parse_dimacs(s, solver);
|
||||
|
||||
if (!FindNextFileA(h,&data))
|
||||
break;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
void tst_dimacs() {
|
||||
tst1();
|
||||
}
|
||||
296
src/test/dead/distinct.cpp
Normal file
296
src/test/dead/distinct.cpp
Normal file
|
|
@ -0,0 +1,296 @@
|
|||
/*++
|
||||
Copyright (c) 2006 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
distinct.cpp
|
||||
|
||||
Abstract:
|
||||
|
||||
<abstract>
|
||||
|
||||
Author:
|
||||
|
||||
Leonardo de Moura (leonardo) 2006-11-03.
|
||||
|
||||
Revision History:
|
||||
|
||||
--*/
|
||||
#include"core_theory.h"
|
||||
|
||||
class distinct_tester {
|
||||
static void tst1() {
|
||||
core_theory t;
|
||||
t.m_params.m_relevancy_lvl = 0;
|
||||
|
||||
enode * n1 = t.mk_const();
|
||||
enode * n2 = t.mk_const();
|
||||
enode * n3 = t.mk_const();
|
||||
enode * d[3] = {n1, n2, n3};
|
||||
|
||||
enode * n4 = t.mk_const();
|
||||
enode * n5 = t.mk_const();
|
||||
enode * n6 = t.mk_const();
|
||||
|
||||
t.assert_distinct_class(3, d);
|
||||
TRACE("distinct", t.display(tout););
|
||||
t.propagate();
|
||||
|
||||
t.push();
|
||||
|
||||
t.assert_lit(t.mk_eq(n1, n2));
|
||||
t.propagate();
|
||||
SASSERT(t.inconsistent());
|
||||
|
||||
t.pop(1);
|
||||
SASSERT(!t.inconsistent());
|
||||
TRACE("distinct", t.display(tout););
|
||||
|
||||
t.push_scope();
|
||||
|
||||
t.assign(t.mk_eq(n1, n4), mk_axiom());
|
||||
t.assign(t.mk_eq(n2, n5), mk_axiom());
|
||||
t.assign(t.mk_eq(n2, n6), mk_axiom());
|
||||
t.propagate();
|
||||
SASSERT(!t.inconsistent());
|
||||
|
||||
t.assign(t.mk_eq(n4,n5), mk_axiom());
|
||||
t.propagate();
|
||||
TRACE("distinct", t.display(tout););
|
||||
SASSERT(t.inconsistent());
|
||||
}
|
||||
|
||||
static void tst2() {
|
||||
core_theory t;
|
||||
t.m_params.m_relevancy_lvl = 0;
|
||||
|
||||
enode * n1 = t.mk_const();
|
||||
enode * n2 = t.mk_const();
|
||||
enode * n3 = t.mk_const();
|
||||
|
||||
t.assert_lit(t.mk_eq(n1,n3));
|
||||
t.propagate();
|
||||
|
||||
enode * d[3] = {n1, n2, n3};
|
||||
|
||||
t.assert_distinct_class(3, d);
|
||||
SASSERT(t.inconsistent());
|
||||
}
|
||||
|
||||
static void tst3() {
|
||||
core_theory t;
|
||||
t.m_params.m_relevancy_lvl = 0;
|
||||
|
||||
enode * n1 = t.mk_const();
|
||||
enode * n2 = t.mk_const();
|
||||
enode * n3 = t.mk_const();
|
||||
|
||||
t.assert_lit(t.mk_eq(n1,n3));
|
||||
|
||||
enode * d[3] = {n1, n2, n3};
|
||||
|
||||
t.assert_distinct_class(3, d);
|
||||
|
||||
t.propagate();
|
||||
SASSERT(t.inconsistent());
|
||||
}
|
||||
|
||||
static void tst4() {
|
||||
#ifdef ENABLE_DISTINCT_CLASSES_SUPPORT
|
||||
core_theory t;
|
||||
t.m_params.m_relevancy_lvl = 0;
|
||||
|
||||
t.push();
|
||||
|
||||
enode * n1 = t.mk_const();
|
||||
enode * n2 = t.mk_const();
|
||||
enode * n3 = t.mk_const();
|
||||
|
||||
enode * d1[3] = {n1, n2, n3};
|
||||
|
||||
t.assert_distinct_class(3, d1);
|
||||
|
||||
SASSERT(n1->get_distinct_classes() == 1);
|
||||
SASSERT(n2->get_distinct_classes() == 1);
|
||||
SASSERT(n3->get_distinct_classes() == 1);
|
||||
|
||||
enode * n4 = t.mk_const();
|
||||
enode * n5 = t.mk_const();
|
||||
enode * n6 = t.mk_const();
|
||||
|
||||
enode * d2[3] = {n4, n5, n6};
|
||||
|
||||
t.assert_distinct_class(3, d2);
|
||||
|
||||
SASSERT(n4->get_distinct_classes() == 2);
|
||||
SASSERT(n5->get_distinct_classes() == 2);
|
||||
SASSERT(n6->get_distinct_classes() == 2);
|
||||
|
||||
enode * n7 = t.mk_const();
|
||||
enode * n8 = t.mk_const();
|
||||
enode * n9 = t.mk_const();
|
||||
|
||||
enode * d3[3] = {n7, n8, n9};
|
||||
|
||||
t.assert_distinct_class(3, d3);
|
||||
|
||||
SASSERT(n7->get_distinct_classes() == 4);
|
||||
SASSERT(n8->get_distinct_classes() == 4);
|
||||
SASSERT(n9->get_distinct_classes() == 4);
|
||||
|
||||
enode * n10 = t.mk_const();
|
||||
enode * n11 = t.mk_const();
|
||||
enode * n12 = t.mk_const();
|
||||
|
||||
enode * d4[3] = {n10, n11, n12};
|
||||
|
||||
t.assert_distinct_class(3, d4);
|
||||
|
||||
SASSERT(n10->get_distinct_classes() == 8);
|
||||
SASSERT(n11->get_distinct_classes() == 8);
|
||||
SASSERT(n12->get_distinct_classes() == 8);
|
||||
|
||||
t.push_scope();
|
||||
|
||||
t.assign(t.mk_eq(n7, n1), mk_axiom());
|
||||
t.propagate();
|
||||
SASSERT(!t.inconsistent());
|
||||
SASSERT(n1->get_root()->get_distinct_classes() == 5);
|
||||
|
||||
t.push_scope();
|
||||
|
||||
t.assign(t.mk_eq(n11, n5), mk_axiom());
|
||||
t.propagate();
|
||||
SASSERT(!t.inconsistent());
|
||||
SASSERT(n5->get_root()->get_distinct_classes() == 10);
|
||||
|
||||
t.push_scope();
|
||||
t.assign(t.mk_eq(n7, n3), mk_axiom());
|
||||
t.propagate();
|
||||
SASSERT(t.inconsistent());
|
||||
|
||||
t.pop_scope(1);
|
||||
SASSERT(!t.inconsistent());
|
||||
|
||||
t.push_scope();
|
||||
|
||||
t.assign(t.mk_eq(n11, n1), mk_axiom());
|
||||
t.propagate();
|
||||
SASSERT(!t.inconsistent());
|
||||
SASSERT(n1->get_root()->get_distinct_classes() == 15);
|
||||
|
||||
t.pop_scope(1);
|
||||
|
||||
SASSERT(!t.inconsistent());
|
||||
SASSERT(n1->get_root()->get_distinct_classes() == 5);
|
||||
SASSERT(n11->get_root()->get_distinct_classes() == 10);
|
||||
SASSERT(n5->get_root()->get_distinct_classes() == 10);
|
||||
|
||||
t.pop_scope(1);
|
||||
SASSERT(n1->get_root()->get_distinct_classes() == 5);
|
||||
SASSERT(n7->get_root()->get_distinct_classes() == 5);
|
||||
SASSERT(n11->get_root()->get_distinct_classes() == 8);
|
||||
SASSERT(n5->get_root()->get_distinct_classes() == 2);
|
||||
|
||||
t.pop_scope(1);
|
||||
SASSERT(n1->get_root()->get_distinct_classes() == 1);
|
||||
SASSERT(n7->get_root()->get_distinct_classes() == 4);
|
||||
SASSERT(n11->get_root()->get_distinct_classes() == 8);
|
||||
SASSERT(n5->get_root()->get_distinct_classes() == 2);
|
||||
|
||||
SASSERT(t.m_num_distinct_classes == 4);
|
||||
|
||||
t.pop(1);
|
||||
|
||||
SASSERT(t.m_num_distinct_classes == 0);
|
||||
#endif
|
||||
}
|
||||
|
||||
static void tst5() {
|
||||
#ifdef ENABLE_DISTINCT_CLASSES_SUPPORT
|
||||
core_theory t;
|
||||
t.m_params.m_relevancy_lvl = 0;
|
||||
|
||||
t.push();
|
||||
|
||||
enode * n1;
|
||||
enode * n2;
|
||||
enode * n3;
|
||||
|
||||
for (unsigned i = 0; i < 40; i++) {
|
||||
n1 = t.mk_const();
|
||||
n2 = t.mk_const();
|
||||
n3 = t.mk_const();
|
||||
|
||||
enode * d1[3] = {n1, n2, n3};
|
||||
|
||||
t.assert_distinct_class(3, d1);
|
||||
}
|
||||
|
||||
SASSERT(t.m_num_distinct_classes == 32);
|
||||
SASSERT(n1->get_root()->get_distinct_classes() == 0);
|
||||
|
||||
t.push_scope();
|
||||
t.assign(t.mk_eq(n1, n3), mk_axiom());
|
||||
t.propagate();
|
||||
|
||||
SASSERT(t.inconsistent());
|
||||
|
||||
t.pop_scope(1);
|
||||
SASSERT(!t.inconsistent());
|
||||
|
||||
t.pop(1);
|
||||
SASSERT(t.m_num_distinct_classes == 0);
|
||||
|
||||
n1 = t.mk_const();
|
||||
n2 = t.mk_const();
|
||||
n3 = t.mk_const();
|
||||
|
||||
enode * d1[3] = {n1, n2, n3};
|
||||
|
||||
t.assert_distinct_class(3, d1);
|
||||
SASSERT(n1->get_root()->get_distinct_classes() == 1);
|
||||
#endif
|
||||
}
|
||||
|
||||
static void tst6() {
|
||||
core_theory t;
|
||||
t.m_params.m_relevancy_lvl = 0;
|
||||
|
||||
t.push_scope();
|
||||
|
||||
enode * n1 = t.mk_const();
|
||||
enode * n2 = t.mk_const();
|
||||
enode * n3 = t.mk_const();
|
||||
|
||||
enode * d1[3] = {n1, n2, n3};
|
||||
|
||||
t.assert_distinct_class(3, d1);
|
||||
|
||||
SASSERT(t.m_num_distinct_classes == 0);
|
||||
SASSERT(n1->get_root()->get_distinct_classes() == 0);
|
||||
|
||||
t.assign(t.mk_eq(n1, n3), mk_axiom());
|
||||
t.propagate();
|
||||
|
||||
SASSERT(t.inconsistent());
|
||||
}
|
||||
|
||||
public:
|
||||
|
||||
static void run_tests() {
|
||||
tst1();
|
||||
tst2();
|
||||
tst3();
|
||||
tst4();
|
||||
tst5();
|
||||
tst6();
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
void tst_distinct() {
|
||||
enable_trace("core_theory_conflict");
|
||||
distinct_tester::run_tests();
|
||||
}
|
||||
|
||||
101
src/test/dead/fingerprint.cpp
Normal file
101
src/test/dead/fingerprint.cpp
Normal file
|
|
@ -0,0 +1,101 @@
|
|||
/*++
|
||||
Copyright (c) 2006 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
fingerprint.cpp
|
||||
|
||||
Abstract:
|
||||
|
||||
Test fingerprint support
|
||||
|
||||
Author:
|
||||
|
||||
Leonardo de Moura (leonardo) 2006-10-29.
|
||||
|
||||
Revision History:
|
||||
|
||||
--*/
|
||||
#include"core_theory.h"
|
||||
|
||||
bool add_fingerprint(core_theory & t, void * data, enode * n1) {
|
||||
enode * c[1];
|
||||
c[0] = n1;
|
||||
return t.add_fingerprint(data, 1, c);
|
||||
}
|
||||
|
||||
bool add_fingerprint(core_theory & t, void * data, enode * n1, enode * n2) {
|
||||
enode * c[2];
|
||||
c[0] = n1;
|
||||
c[1] = n2;
|
||||
return t.add_fingerprint(data, 2, c);
|
||||
}
|
||||
|
||||
bool add_fingerprint(core_theory & t, void * data, enode * n1, enode * n2, enode * n3, enode * n4, enode * n5, enode * n6, enode * n7, enode * n8, enode * n9) {
|
||||
enode * c[9];
|
||||
c[0] = n1;
|
||||
c[1] = n2;
|
||||
c[2] = n3;
|
||||
c[3] = n4;
|
||||
c[4] = n5;
|
||||
c[5] = n6;
|
||||
c[6] = n7;
|
||||
c[7] = n8;
|
||||
c[8] = n9;
|
||||
return t.add_fingerprint(data, 9, c);
|
||||
}
|
||||
|
||||
class fingerprint_tester {
|
||||
|
||||
static void tst1() {
|
||||
core_theory t;
|
||||
enode * n1 = t.mk_const();
|
||||
enode * n2 = t.mk_const();
|
||||
enode * n3 = t.mk_const();
|
||||
void * d1 = reinterpret_cast<void *>(1);
|
||||
|
||||
SASSERT(add_fingerprint(t, 0, n1));
|
||||
SASSERT(!add_fingerprint(t, 0, n1));
|
||||
SASSERT(add_fingerprint(t, 0, n2));
|
||||
|
||||
SASSERT(add_fingerprint(t, d1, n1));
|
||||
SASSERT(!add_fingerprint(t, d1, n1));
|
||||
SASSERT(add_fingerprint(t, d1, n2));
|
||||
SASSERT(add_fingerprint(t, d1, n1, n2));
|
||||
SASSERT(add_fingerprint(t, d1, n2, n1));
|
||||
SASSERT(!add_fingerprint(t, d1, n1, n2));
|
||||
SASSERT(!add_fingerprint(t, d1, n2, n1));
|
||||
|
||||
t.push_scope();
|
||||
|
||||
SASSERT(add_fingerprint(t, 0, n3));
|
||||
SASSERT(add_fingerprint(t, d1, n3));
|
||||
SASSERT(add_fingerprint(t, d1, n1, n1, n1, n1, n1, n1, n2, n1, n2));
|
||||
SASSERT(!add_fingerprint(t, d1, n1, n1, n1, n1, n1, n1, n2, n1, n2));
|
||||
SASSERT(add_fingerprint(t, d1, n1, n1, n1, n1, n1, n1, n2, n1, n1));
|
||||
SASSERT(!add_fingerprint(t, d1, n1, n1, n1, n1, n1, n1, n2, n1, n1));
|
||||
|
||||
t.pop_scope(1);
|
||||
|
||||
SASSERT(!add_fingerprint(t, 0, n1));
|
||||
SASSERT(!add_fingerprint(t, 0, n2));
|
||||
SASSERT(!add_fingerprint(t, d1, n1, n2));
|
||||
SASSERT(!add_fingerprint(t, d1, n2, n1));
|
||||
SASSERT(add_fingerprint(t, 0, n3));
|
||||
SASSERT(add_fingerprint(t, d1, n3));
|
||||
SASSERT(add_fingerprint(t, d1, n1, n1, n1, n1, n1, n1, n2, n1, n2));
|
||||
SASSERT(!add_fingerprint(t, d1, n1, n1, n1, n1, n1, n1, n2, n1, n2));
|
||||
SASSERT(add_fingerprint(t, d1, n1, n1, n1, n1, n1, n1, n2, n1, n1));
|
||||
SASSERT(!add_fingerprint(t, d1, n1, n1, n1, n1, n1, n1, n2, n1, n1));
|
||||
}
|
||||
|
||||
public:
|
||||
|
||||
static void run_tests() {
|
||||
tst1();
|
||||
}
|
||||
};
|
||||
|
||||
void tst_fingerprint() {
|
||||
fingerprint_tester::run_tests();
|
||||
}
|
||||
472
src/test/dead/gate.cpp
Normal file
472
src/test/dead/gate.cpp
Normal file
|
|
@ -0,0 +1,472 @@
|
|||
/*++
|
||||
Copyright (c) 2006 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
gate.cpp
|
||||
|
||||
Abstract:
|
||||
|
||||
Test SAT gates
|
||||
|
||||
Author:
|
||||
|
||||
Leonardo de Moura (leonardo) 2006-11-02.
|
||||
|
||||
Revision History:
|
||||
|
||||
--*/
|
||||
#include"sat_def.h"
|
||||
|
||||
class gate_extension : public no_extension {
|
||||
public:
|
||||
bool relevancy_enabled() {
|
||||
return true;
|
||||
}
|
||||
|
||||
bool gates_enabled() {
|
||||
return true;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
class gate_no_rel_extension : public no_extension {
|
||||
public:
|
||||
bool relevancy_enabled() {
|
||||
return false;
|
||||
}
|
||||
|
||||
bool gates_enabled() {
|
||||
return true;
|
||||
}
|
||||
};
|
||||
|
||||
class sat_gate_tester {
|
||||
|
||||
static void tst1() {
|
||||
sat_solver<gate_no_rel_extension> solver;
|
||||
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_var();
|
||||
literal l3 = solver.mk_var();
|
||||
|
||||
SASSERT(solver.mk_or(l1, l2, l3) == solver.mk_or(l3, l1, l2));
|
||||
|
||||
SASSERT(solver.mk_or(l1, l1, l3) == solver.mk_or(l3, l1));
|
||||
|
||||
SASSERT(solver.mk_or(l1, l1, l1) == l1);
|
||||
|
||||
SASSERT(solver.mk_or(l1, false_literal, l1) == l1);
|
||||
|
||||
SASSERT(solver.mk_or(l1, true_literal, l1) == true_literal);
|
||||
|
||||
solver.assert_lit(l1);
|
||||
|
||||
SASSERT(solver.mk_or(l1, l2, l3) == true_literal);
|
||||
|
||||
literal l4 = solver.mk_or(l2, l3);
|
||||
|
||||
SASSERT(l4 != true_literal && l4 != false_literal);
|
||||
|
||||
solver.push();
|
||||
|
||||
solver.assert_lit(l2);
|
||||
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.get_assignment(l4) == l_true);
|
||||
|
||||
solver.pop(1);
|
||||
|
||||
SASSERT(solver.get_assignment(l4) == l_undef);
|
||||
|
||||
solver.push();
|
||||
|
||||
solver.assert_lit(~l2);
|
||||
|
||||
solver.assert_lit(~l3);
|
||||
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.get_assignment(l4) == l_false);
|
||||
|
||||
solver.pop(1);
|
||||
|
||||
SASSERT(solver.get_assignment(l4) == l_undef);
|
||||
|
||||
SASSERT(l4 == ~solver.mk_and(~l2, ~l3));
|
||||
}
|
||||
|
||||
static void tst1a() {
|
||||
sat_solver<gate_extension> solver;
|
||||
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_var();
|
||||
literal l3 = solver.mk_var();
|
||||
|
||||
SASSERT(solver.mk_or(l1, l2, l3) == solver.mk_or(l3, l1, l2));
|
||||
|
||||
SASSERT(solver.mk_or(l1, l1, l3) == solver.mk_or(l3, l1));
|
||||
|
||||
SASSERT(solver.mk_or(l1, l1, l1) == l1);
|
||||
|
||||
SASSERT(solver.mk_or(l1, false_literal, l1) == l1);
|
||||
|
||||
SASSERT(solver.mk_or(l1, true_literal, l1) == true_literal);
|
||||
|
||||
solver.assert_lit(l1);
|
||||
|
||||
SASSERT(solver.mk_or(l1, l2, l3) != true_literal);
|
||||
|
||||
literal l4 = solver.mk_or(l2, l3);
|
||||
|
||||
SASSERT(l4 != true_literal && l4 != false_literal);
|
||||
|
||||
solver.push();
|
||||
|
||||
solver.assert_lit(l2);
|
||||
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.get_assignment(l4) == l_true);
|
||||
|
||||
solver.pop(1);
|
||||
|
||||
SASSERT(solver.get_assignment(l4) == l_undef);
|
||||
|
||||
solver.push();
|
||||
|
||||
solver.assert_lit(~l2);
|
||||
|
||||
solver.assert_lit(~l3);
|
||||
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.get_assignment(l4) == l_false);
|
||||
|
||||
solver.pop(1);
|
||||
|
||||
SASSERT(solver.get_assignment(l4) == l_undef);
|
||||
|
||||
SASSERT(l4 == ~solver.mk_and(~l2, ~l3));
|
||||
}
|
||||
|
||||
static void tst2() {
|
||||
sat_solver<gate_extension> solver;
|
||||
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_var();
|
||||
literal l3 = solver.mk_var();
|
||||
|
||||
SASSERT(solver.mk_iff(l1, l2) == solver.mk_iff(l2, l1));
|
||||
|
||||
SASSERT(solver.mk_iff(l1, true_literal) == l1);
|
||||
|
||||
SASSERT(solver.mk_iff(l1, false_literal) == ~l1);
|
||||
|
||||
SASSERT(solver.mk_iff(true_literal, l2) == l2);
|
||||
|
||||
SASSERT(solver.mk_iff(false_literal, l2) == ~l2);
|
||||
|
||||
SASSERT(solver.mk_iff(l1, l1) == true_literal);
|
||||
|
||||
SASSERT(solver.mk_iff(l1, ~l1) == false_literal);
|
||||
}
|
||||
|
||||
static void tst3() {
|
||||
sat_solver<gate_extension> solver;
|
||||
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_var();
|
||||
|
||||
solver.push();
|
||||
|
||||
literal l3 = solver.mk_or(l1, l2);
|
||||
SASSERT(solver.m_ref_count[l3.var()] == 1);
|
||||
|
||||
solver.pop(1);
|
||||
}
|
||||
|
||||
static void tst4() {
|
||||
sat_solver<gate_extension> solver;
|
||||
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_var();
|
||||
|
||||
literal l3 = solver.mk_or(l1, l2);
|
||||
|
||||
solver.reset();
|
||||
|
||||
l1 = solver.mk_var();
|
||||
|
||||
}
|
||||
|
||||
static void tst5() {
|
||||
sat_solver<gate_extension> solver;
|
||||
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_var();
|
||||
literal l3 = solver.mk_var();
|
||||
|
||||
solver.push_scope();
|
||||
|
||||
solver.assign(l1, mk_axiom());
|
||||
|
||||
solver.propagate();
|
||||
|
||||
solver.push_scope();
|
||||
|
||||
literal l4 = solver.mk_or(l1, l2);
|
||||
|
||||
solver.mk_main_clause(l4, l3);
|
||||
|
||||
SASSERT(solver.get_assignment(l4) == l_true);
|
||||
|
||||
solver.pop_scope(1);
|
||||
|
||||
SASSERT(solver.get_assignment(l4) == l_true);
|
||||
}
|
||||
|
||||
static void tst6() {
|
||||
sat_solver<gate_no_rel_extension> solver;
|
||||
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_var();
|
||||
literal l3 = solver.mk_var();
|
||||
literal l4 = solver.mk_var();
|
||||
|
||||
SASSERT(solver.mk_ite(l1, l2, l3) == solver.mk_ite(~l1, l3, l2));
|
||||
|
||||
SASSERT(solver.mk_ite(l1, l2, l2) == l2);
|
||||
|
||||
solver.assert_lit(l1);
|
||||
|
||||
solver.push_scope();
|
||||
|
||||
SASSERT(solver.mk_ite(l1, l2, l3) == l2);
|
||||
|
||||
SASSERT(solver.mk_ite(~l1, l2, l3) == l3);
|
||||
}
|
||||
|
||||
static void tst6a() {
|
||||
sat_solver<gate_extension> solver;
|
||||
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_var();
|
||||
literal l3 = solver.mk_var();
|
||||
literal l4 = solver.mk_var();
|
||||
|
||||
SASSERT(solver.mk_ite(l1, l2, l3) == solver.mk_ite(~l1, l3, l2));
|
||||
|
||||
SASSERT(solver.mk_ite(l1, l2, l2) == l2);
|
||||
|
||||
solver.assert_lit(l1);
|
||||
|
||||
solver.push_scope();
|
||||
|
||||
SASSERT(solver.mk_ite(l1, l2, l3) != l2);
|
||||
|
||||
SASSERT(solver.mk_ite(~l1, l2, l3) != l3);
|
||||
}
|
||||
|
||||
static void tst7() {
|
||||
sat_solver<gate_extension> solver;
|
||||
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_uniq(l1);
|
||||
SASSERT(l1 != l2);
|
||||
|
||||
solver.push();
|
||||
|
||||
solver.assert_lit(l1);
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.get_assignment(l1) == l_true);
|
||||
SASSERT(solver.get_assignment(l2) == l_true);
|
||||
|
||||
solver.pop(1);
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.get_assignment(l1) == l_undef);
|
||||
SASSERT(solver.get_assignment(l2) == l_undef);
|
||||
|
||||
solver.assert_lit(~l1);
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.get_assignment(l1) == l_false);
|
||||
SASSERT(solver.get_assignment(l2) == l_false);
|
||||
}
|
||||
|
||||
static void tst8() {
|
||||
sat_solver<gate_extension> solver;
|
||||
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_uniq(l1);
|
||||
SASSERT(l1 != l2);
|
||||
|
||||
solver.push_scope();
|
||||
|
||||
solver.assert_lit(l1);
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.get_assignment(l1) == l_true);
|
||||
SASSERT(solver.get_assignment(l2) == l_true);
|
||||
|
||||
solver.pop_scope(1);
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.get_assignment(l1) == l_true);
|
||||
SASSERT(solver.get_assignment(l2) == l_true);
|
||||
}
|
||||
|
||||
static void tst9() {
|
||||
sat_solver<gate_extension> s;
|
||||
|
||||
literal l1 = s.mk_var();
|
||||
literal l2 = s.mk_var();
|
||||
literal l3 = s.mk_var();
|
||||
|
||||
s.push_scope();
|
||||
s.assign(l1, mk_axiom());
|
||||
s.push_scope();
|
||||
literal l4 = s.mk_var();
|
||||
literal l5 = s.mk_var();
|
||||
literal l6 = s.mk_or(l4, l5);
|
||||
s.assign(l6, mk_axiom());
|
||||
s.mk_transient_clause(~l6, l3);
|
||||
s.mk_transient_clause(~l6, l2);
|
||||
s.mk_transient_clause(literal_vector(~l3, ~l1, ~l2));
|
||||
SASSERT(s.inconsistent());
|
||||
#ifdef Z3DEBUG
|
||||
bool r =
|
||||
#endif
|
||||
s.resolve_conflict();
|
||||
SASSERT(r);
|
||||
SASSERT(s.m_scope_lvl == 1);
|
||||
SASSERT(s.m_ref_count[l4.var()] > 0);
|
||||
SASSERT(s.m_ref_count[l5.var()] > 0);
|
||||
SASSERT(s.m_ref_count[l6.var()] > 0);
|
||||
s.pop_scope(1);
|
||||
SASSERT(s.get_assignment(l1) == l_undef);
|
||||
SASSERT(s.get_assignment(l4) == l_undef);
|
||||
SASSERT(s.get_assignment(l5) == l_undef);
|
||||
SASSERT(s.get_assignment(l6) == l_undef);
|
||||
SASSERT(s.m_ref_count[l4.var()] > 0);
|
||||
SASSERT(s.m_ref_count[l5.var()] > 0);
|
||||
SASSERT(s.m_ref_count[l6.var()] > 0);
|
||||
s.push_scope();
|
||||
s.assign(~l4, mk_axiom());
|
||||
s.propagate();
|
||||
#ifdef Z3DEBUG
|
||||
s.del_learned_clauses();
|
||||
#endif
|
||||
s.pop_scope(1);
|
||||
}
|
||||
|
||||
static void tst10() {
|
||||
sat_solver<gate_extension> s;
|
||||
|
||||
literal l1 = s.mk_var();
|
||||
literal l2 = s.mk_var();
|
||||
literal l3 = s.mk_var();
|
||||
|
||||
s.push_scope();
|
||||
s.assign(l1, mk_axiom());
|
||||
s.push_scope();
|
||||
literal l4 = s.mk_var();
|
||||
literal l5 = s.mk_var();
|
||||
literal l6 = s.mk_iff(l4, l5);
|
||||
literal l7 = s.mk_var();
|
||||
literal l8 = s.mk_or(l6, l7);
|
||||
s.assign(l8, mk_axiom());
|
||||
s.mk_transient_clause(~l8, l3);
|
||||
s.mk_transient_clause(~l8, l2);
|
||||
s.mk_transient_clause(literal_vector(~l3, ~l1, ~l2));
|
||||
SASSERT(s.inconsistent());
|
||||
#ifdef Z3DEBUG
|
||||
bool r =
|
||||
#endif
|
||||
s.resolve_conflict();
|
||||
SASSERT(r);
|
||||
SASSERT(s.m_scope_lvl == 1);
|
||||
s.pop_scope(1);
|
||||
SASSERT(s.m_ref_count[l4.var()] > 0);
|
||||
SASSERT(s.m_ref_count[l5.var()] > 0);
|
||||
SASSERT(s.m_ref_count[l6.var()] > 0);
|
||||
SASSERT(s.m_ref_count[l7.var()] > 0);
|
||||
SASSERT(s.m_ref_count[l8.var()] > 0);
|
||||
s.push_scope();
|
||||
s.assign(~l1, mk_axiom());
|
||||
s.push_scope();
|
||||
s.assign(l5, mk_axiom());
|
||||
s.mk_transient_clause(~l5, ~l4);
|
||||
s.propagate();
|
||||
SASSERT(s.get_assignment(l6) == l_false);
|
||||
SASSERT(s.get_assignment(l8) == l_undef);
|
||||
#ifdef Z3DEBUG
|
||||
s.del_learned_clauses();
|
||||
SASSERT(s.m_ref_count[l7.var()] == 0);
|
||||
SASSERT(s.m_ref_count[l8.var()] == 0);
|
||||
SASSERT(s.m_ref_count[l4.var()] > 0);
|
||||
SASSERT(s.m_ref_count[l5.var()] > 0);
|
||||
SASSERT(s.m_ref_count[l6.var()] > 0);
|
||||
#endif
|
||||
s.mk_transient_clause(l6, l3);
|
||||
s.mk_transient_clause(l6, l2);
|
||||
s.mk_transient_clause(literal_vector(~l3, l1, ~l2));
|
||||
SASSERT(s.inconsistent());
|
||||
#ifdef Z3DEBUG
|
||||
r =
|
||||
#endif
|
||||
s.resolve_conflict();
|
||||
SASSERT(r);
|
||||
}
|
||||
|
||||
static void tst11() {
|
||||
sat_solver<gate_extension> s;
|
||||
|
||||
literal l0 = s.mk_var();
|
||||
literal l1 = s.mk_var();
|
||||
literal l2 = s.mk_var();
|
||||
|
||||
s.push_scope();
|
||||
s.assign(~l1, mk_axiom());
|
||||
s.assign(~l2, mk_axiom());
|
||||
s.push_scope();
|
||||
literal l3 = s.mk_or(l1, l2);
|
||||
SASSERT(s.get_assignment(l3) == l_false);
|
||||
s.mk_main_clause(l0, l1, l3);
|
||||
SASSERT(s.m_ref_count[l3.var()] == 3);
|
||||
s.pop_scope(1);
|
||||
SASSERT(s.m_ref_count[l3.var()] == 2);
|
||||
SASSERT(s.get_assignment(l3) == l_false);
|
||||
s.assert_lit(l1);
|
||||
s.propagate();
|
||||
SASSERT(s.inconsistent());
|
||||
}
|
||||
|
||||
public:
|
||||
static void run_tests() {
|
||||
enable_trace("del_gate");
|
||||
enable_trace("sat_solver");
|
||||
enable_trace("gate");
|
||||
enable_trace("del_learned_clauses");
|
||||
tst1();
|
||||
tst1a();
|
||||
tst2();
|
||||
tst3();
|
||||
tst4();
|
||||
tst5();
|
||||
tst6();
|
||||
tst6a();
|
||||
tst7();
|
||||
tst8();
|
||||
tst9();
|
||||
tst10();
|
||||
tst11();
|
||||
}
|
||||
};
|
||||
|
||||
void tst_gate() {
|
||||
sat_gate_tester::run_tests();
|
||||
}
|
||||
243
src/test/dead/interval_arithmetic.cpp
Normal file
243
src/test/dead/interval_arithmetic.cpp
Normal file
|
|
@ -0,0 +1,243 @@
|
|||
/*++
|
||||
Copyright (c) 2006 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
interval_arithmetic.cpp
|
||||
|
||||
Abstract:
|
||||
|
||||
Test interval arithmetic
|
||||
|
||||
Author:
|
||||
|
||||
Nikolaj Bjorner (nbjorner) 2006-12-05.
|
||||
|
||||
Revision History:
|
||||
|
||||
--*/
|
||||
#include<iostream>
|
||||
#include"interval_arithmetic.h"
|
||||
#include"trace.h"
|
||||
|
||||
|
||||
template<class number, class epsilon>
|
||||
void tst_ext_number() {
|
||||
typedef ext_number<number, epsilon> num;
|
||||
num zero;
|
||||
num one(1);
|
||||
num eps(num::epsilon());
|
||||
num m_eps(num::epsilon().neg());
|
||||
num two(number(2));
|
||||
num half(number(1,2));
|
||||
num inf = num::infinity();
|
||||
num eps1 = num::epsilon();
|
||||
num three(number(3));
|
||||
num three_e = num::plus(three, num::epsilon());
|
||||
SASSERT(zero.get_sign() == num::ZERO);
|
||||
SASSERT(one.get_sign() == num::POSITIVE);
|
||||
SASSERT(m_eps.get_sign() == num::NEGATIVE);
|
||||
SASSERT(inf.get_sign() == num::POSITIVE);
|
||||
SASSERT(zero.is_zero());
|
||||
SASSERT(!one.is_zero());
|
||||
SASSERT(!inf.is_zero());
|
||||
SASSERT(inf.is_infinite());
|
||||
SASSERT(!one.is_infinite());
|
||||
SASSERT(one.is_pos());
|
||||
SASSERT(m_eps.is_neg());
|
||||
SASSERT(one != zero);
|
||||
SASSERT(inf != one);
|
||||
SASSERT(inf != zero);
|
||||
SASSERT(zero == zero);
|
||||
SASSERT(zero < one);
|
||||
SASSERT(eps < two);
|
||||
SASSERT(zero < eps);
|
||||
SASSERT(zero < inf);
|
||||
SASSERT(zero == min(zero, eps));
|
||||
SASSERT(zero == min(zero, inf));
|
||||
SASSERT(eps == max(zero, eps));
|
||||
SASSERT(inf == max(zero, inf));
|
||||
SASSERT(min(zero,eps) == min(eps,zero));
|
||||
SASSERT(num::plus(zero, eps) == eps);
|
||||
SASSERT(num::plus(zero, one) == one);
|
||||
SASSERT(num::plus(zero, inf) == inf);
|
||||
SASSERT(num::plus(inf, inf) == inf);
|
||||
SASSERT(inf.neg() < inf);
|
||||
SASSERT(inf.neg() < zero);
|
||||
SASSERT(num::minus(zero, one) == one.neg());
|
||||
SASSERT(num::minus(zero, eps) == eps.neg());
|
||||
SASSERT(num::minus(zero, inf) == inf.neg());
|
||||
SASSERT(num::minus(zero, inf.neg()) == inf);
|
||||
SASSERT(num::minus(inf, inf.neg()) == inf);
|
||||
|
||||
// sup_mult, inf_mult
|
||||
SASSERT(sup_mult(zero, one) == zero);
|
||||
SASSERT(sup_mult(one, one) == one);
|
||||
SASSERT(sup_mult(one, one.neg()) == one.neg());
|
||||
SASSERT(inf_mult(zero, one) == zero);
|
||||
SASSERT(inf_mult(one, one) == one);
|
||||
SASSERT(inf_mult(one, one.neg()) == one.neg());
|
||||
|
||||
// sup_div, inf_div
|
||||
SASSERT(one < sup_div(three_e, three));
|
||||
SASSERT(inf_div(three, three_e) < one);
|
||||
SASSERT(inf_div(three_e, three) < two);
|
||||
SASSERT(inf_div(three.neg(), three_e.neg()) < one);
|
||||
SASSERT(one < sup_div(three_e.neg(), three.neg()));
|
||||
SASSERT(inf_div(three_e.neg(), three.neg()) < two);
|
||||
|
||||
// sup_power, inf_power
|
||||
SASSERT(sup_power(one,3) == one);
|
||||
SASSERT(sup_power(one,3) > zero);
|
||||
SASSERT(sup_power(num::plus(one, num::epsilon()),3) > one);
|
||||
|
||||
SASSERT(sup_power(one,2) == one);
|
||||
SASSERT(sup_power(one,2) > zero);
|
||||
SASSERT(sup_power(num::plus(one, num::epsilon()),2) > one);
|
||||
|
||||
// sup_root, inf_root
|
||||
SASSERT(sup_root(one,2) >= zero);
|
||||
SASSERT(inf_root(one,2) <= one);
|
||||
SASSERT(sup_root(zero,2) >= zero);
|
||||
SASSERT(inf_root(zero,2) <= zero);
|
||||
|
||||
}
|
||||
|
||||
template<class number, class epsilon>
|
||||
void tst_interval()
|
||||
{
|
||||
typedef interval<number, epsilon> interval;
|
||||
typedef ext_number<number, epsilon> ext_num;
|
||||
ext_num m_inf(ext_num::infinity().neg());
|
||||
ext_num m_three(ext_num(3).neg());
|
||||
ext_num m_three_m_e(ext_num::plus(ext_num(3), ext_num::epsilon()).neg());
|
||||
ext_num m_three_p_e(ext_num::plus(ext_num(3), ext_num::epsilon().neg()).neg());
|
||||
ext_num m_eps(ext_num::epsilon().neg());
|
||||
ext_num zero(0);
|
||||
ext_num eps(ext_num::epsilon());
|
||||
ext_num three(ext_num(3));
|
||||
ext_num three_m_e(ext_num::minus(ext_num(3), ext_num::epsilon()));
|
||||
ext_num three_p_e(ext_num::plus(ext_num(3), ext_num::epsilon()));
|
||||
ext_num inf(ext_num::infinity());
|
||||
ext_num nums[] = { m_inf, m_three_m_e, m_three, m_three_p_e, m_eps, zero, eps, three_m_e, three, three_p_e, inf };
|
||||
|
||||
unsigned n_nums = 11;
|
||||
//
|
||||
// add_lower
|
||||
// add_upper
|
||||
//
|
||||
for (unsigned i = 0; i < n_nums; ++i) {
|
||||
for (unsigned j = i+1; j < n_nums; ++j) {
|
||||
|
||||
for (unsigned k = 0; k < n_nums; ++k) {
|
||||
interval i1(nums[i], nums[j]);
|
||||
bool ok = i1.add_lower(nums[k]);
|
||||
TRACE("interval_arithmetic", tout << "lower: " << ok << " "
|
||||
<< nums[k] << " " << i1 << std::endl;);
|
||||
}
|
||||
|
||||
for (unsigned k = 0; k < n_nums; ++k) {
|
||||
interval i1(nums[i], nums[j]);
|
||||
bool ok = i1.add_upper(nums[k]);
|
||||
TRACE("interval_arithmetic", tout << "upper: " << ok << " "
|
||||
<< nums[k] << " " << i1 << std::endl;);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// +
|
||||
// *
|
||||
// -
|
||||
// quotient
|
||||
//
|
||||
for (unsigned i = 0; i < n_nums; ++i) {
|
||||
for (unsigned j = i+1; j < n_nums; ++j) {
|
||||
interval i1(nums[i],nums[j]);
|
||||
|
||||
interval x = i1.power(0);
|
||||
interval y = i1.power(1);
|
||||
interval z = i1.power(2);
|
||||
interval x1 = i1.power(3);
|
||||
|
||||
for (unsigned k = 0; k < n_nums; ++k) {
|
||||
for (unsigned l = k+1; l < n_nums; ++l) {
|
||||
interval i2(nums[k],nums[l]);
|
||||
interval i3 = i1 + i2;
|
||||
interval i4 = i1 - i2;
|
||||
interval i5 = i1 * i2;
|
||||
TRACE("interval_arithmetic", tout << i1 << " + " << i2 << " = " << i3 << std::endl;);
|
||||
TRACE("interval_arithmetic", tout << i1 << " - " << i2 << " = " << i4 << std::endl;);
|
||||
TRACE("interval_arithmetic", tout << i1 << " * " << i2 << " = " << i5 << std::endl;);
|
||||
SASSERT(i5 == i2 * i1);
|
||||
vector<interval, true> intervals;
|
||||
interval::quotient(i1, i2, intervals);
|
||||
TRACE("interval_arithmetic",
|
||||
tout << i1 << " / " << i2 << " = " ;
|
||||
for (unsigned idx = 0; idx < intervals.size(); ++idx) {
|
||||
tout << intervals[idx] << " ";
|
||||
}
|
||||
tout << std::endl;
|
||||
);
|
||||
|
||||
unsigned changed_bounds;
|
||||
x = i1;
|
||||
y = i2;
|
||||
z = i3;
|
||||
TRACE("interval_arithmetic", tout << "check: " << i1 << "=" << i2 << "*" << i3 << std::endl;);
|
||||
if (interval::check_mult(x, y, z, changed_bounds)) {
|
||||
TRACE("interval_arithmetic", tout << x << "=" << y << "*" << z << std::endl;);
|
||||
SASSERT (!!(changed_bounds & 0x1) == (x.low() != i1.low()));
|
||||
SASSERT (!!(changed_bounds & 0x2) == (x.high() != i1.high()));
|
||||
SASSERT (!!(changed_bounds & 0x4) == (y.low() != i2.low()));
|
||||
SASSERT (!!(changed_bounds & 0x8) == (y.high() != i2.high()));
|
||||
SASSERT (!!(changed_bounds & 0x10) == (z.low() != i3.low()));
|
||||
SASSERT (!!(changed_bounds & 0x20) == (z.high() != i3.high()));
|
||||
}
|
||||
else {
|
||||
TRACE("interval_arithmetic", tout << "unsat" << std::endl;);
|
||||
}
|
||||
|
||||
x = i1;
|
||||
y = i2;
|
||||
if (interval::check_power(x, y, 3, changed_bounds)) {
|
||||
TRACE("interval_arithmetic",
|
||||
tout << "check: " << i1 << "=" << i2 << "^3" << " -> "
|
||||
<< x << " = " << y << "^3" << std::endl;);
|
||||
}
|
||||
else {
|
||||
TRACE("interval_arithmetic", tout << "unsat: " << i1 << "=" << i2 << "^4" << std::endl;);
|
||||
}
|
||||
|
||||
|
||||
x = i1;
|
||||
y = i2;
|
||||
if (interval::check_power(x, y, 4, changed_bounds)) {
|
||||
TRACE("interval_arithmetic",
|
||||
tout << "check: " << i1 << "=" << i2 << "^4" << " -> "
|
||||
<< x << " = " << y << "^4" << std::endl;);
|
||||
}
|
||||
else {
|
||||
TRACE("interval_arithmetic", tout << "unsat: " << i1 << "=" << i2 << "^4" << std::endl;);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// check_mult(i1, i2, i3, change_bounds);
|
||||
|
||||
// check_power(i1, i2, power, changed_bounds);
|
||||
}
|
||||
|
||||
struct eps1 { rational operator()() { return rational(1); } };
|
||||
struct eps0 { inf_rational operator()() { return inf_rational(rational(0),true); } };
|
||||
|
||||
void tst_interval_arithmetic() {
|
||||
TRACE("interval_arithmetic", tout << "starting interval_arithmetic test...\n";);
|
||||
tst_ext_number<rational, eps1>();
|
||||
tst_ext_number<inf_rational, eps0>();
|
||||
tst_interval<rational, eps1>();
|
||||
tst_interval<inf_rational, eps0>();
|
||||
}
|
||||
653
src/test/dead/relevancy.cpp
Normal file
653
src/test/dead/relevancy.cpp
Normal file
|
|
@ -0,0 +1,653 @@
|
|||
/*++
|
||||
Copyright (c) 2006 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
relevancy.cpp
|
||||
|
||||
Abstract:
|
||||
|
||||
Test relevancy propagation.
|
||||
|
||||
Author:
|
||||
|
||||
Leonardo de Moura (leonardo) 2006-11-03.
|
||||
|
||||
Revision History:
|
||||
|
||||
--*/
|
||||
#include"sat_def.h"
|
||||
|
||||
class relevancy_extension : public no_extension {
|
||||
public:
|
||||
bool relevancy_enabled() {
|
||||
return true;
|
||||
}
|
||||
|
||||
bool gates_enabled() {
|
||||
return true;
|
||||
}
|
||||
};
|
||||
|
||||
class sat_relevancy_tester {
|
||||
|
||||
static void tst1() {
|
||||
sat_solver<relevancy_extension> solver;
|
||||
|
||||
literal l1 = solver.mk_var();
|
||||
|
||||
SASSERT(!solver.is_relevant(l1.var()));
|
||||
|
||||
solver.assert_lit(l1);
|
||||
|
||||
SASSERT(solver.is_relevant(l1.var()));
|
||||
}
|
||||
|
||||
static void tst2() {
|
||||
sat_solver<relevancy_extension> solver;
|
||||
|
||||
literal l1 = solver.mk_var();
|
||||
|
||||
solver.push_scope();
|
||||
|
||||
SASSERT(!solver.is_relevant(l1.var()));
|
||||
|
||||
solver.assert_lit(l1);
|
||||
|
||||
SASSERT(solver.is_relevant(l1.var()));
|
||||
|
||||
solver.pop_scope(1);
|
||||
|
||||
SASSERT(solver.is_relevant(l1.var()));
|
||||
}
|
||||
|
||||
static void tst3() {
|
||||
sat_solver<relevancy_extension> solver;
|
||||
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_var();
|
||||
literal l3 = solver.mk_var();
|
||||
|
||||
literal l4 = solver.mk_ite(l1, l2, l3);
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(!solver.is_relevant(l3));
|
||||
SASSERT(!solver.is_relevant(l4));
|
||||
|
||||
solver.mark_as_relevant(l4.var());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(!solver.is_relevant(l3));
|
||||
SASSERT(solver.is_relevant(l4));
|
||||
|
||||
solver.push_scope();
|
||||
|
||||
solver.assign(l1, mk_axiom());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.is_relevant(l1));
|
||||
SASSERT(solver.is_relevant(l2));
|
||||
SASSERT(!solver.is_relevant(l3));
|
||||
SASSERT(solver.is_relevant(l4));
|
||||
|
||||
solver.pop_scope(1);
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(!solver.is_relevant(l3));
|
||||
SASSERT(solver.is_relevant(l4));
|
||||
|
||||
solver.assign(~l1, mk_axiom());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(solver.is_relevant(l3));
|
||||
SASSERT(solver.is_relevant(l4));
|
||||
}
|
||||
|
||||
static void tst4() {
|
||||
sat_solver<relevancy_extension> solver;
|
||||
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_var();
|
||||
literal l3 = solver.mk_var();
|
||||
literal l4 = solver.mk_ite(l1, l2, l3);
|
||||
solver.propagate();
|
||||
|
||||
solver.push_scope();
|
||||
|
||||
solver.assign(l1, mk_axiom());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(!solver.is_relevant(l3));
|
||||
SASSERT(!solver.is_relevant(l4));
|
||||
|
||||
solver.mark_as_relevant(l4.var());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.is_relevant(l1));
|
||||
SASSERT(solver.is_relevant(l2));
|
||||
SASSERT(!solver.is_relevant(l3));
|
||||
SASSERT(solver.is_relevant(l4));
|
||||
|
||||
solver.pop_scope(1);
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(!solver.is_relevant(l3));
|
||||
SASSERT(!solver.is_relevant(l4));
|
||||
|
||||
solver.assign(~l1, mk_axiom());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(!solver.is_relevant(l3));
|
||||
SASSERT(!solver.is_relevant(l4));
|
||||
|
||||
solver.mark_as_relevant(l4.var());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(solver.is_relevant(l3));
|
||||
SASSERT(solver.is_relevant(l4));
|
||||
}
|
||||
|
||||
static void tst5() {
|
||||
sat_solver<relevancy_extension> solver;
|
||||
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_var();
|
||||
literal l3 = solver.mk_var();
|
||||
|
||||
solver.push_scope();
|
||||
|
||||
solver.assign(l1, mk_axiom());
|
||||
solver.propagate();
|
||||
|
||||
literal l4 = solver.mk_ite(l1, l2, l3);
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(!solver.is_relevant(l3));
|
||||
SASSERT(!solver.is_relevant(l4));
|
||||
|
||||
solver.mark_as_relevant(l4.var());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.is_relevant(l1));
|
||||
SASSERT(solver.is_relevant(l2));
|
||||
SASSERT(!solver.is_relevant(l3));
|
||||
SASSERT(solver.is_relevant(l4));
|
||||
}
|
||||
|
||||
static void tst6() {
|
||||
sat_solver<relevancy_extension> solver;
|
||||
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_var();
|
||||
literal l3 = solver.mk_iff(l1, l2);
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(!solver.is_relevant(l3));
|
||||
|
||||
solver.push_scope();
|
||||
|
||||
solver.mark_as_relevant(l3.var());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.is_relevant(l1));
|
||||
SASSERT(solver.is_relevant(l2));
|
||||
SASSERT(solver.is_relevant(l3));
|
||||
|
||||
solver.pop_scope(1);
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(!solver.is_relevant(l3));
|
||||
|
||||
solver.push_scope();
|
||||
|
||||
solver.mark_as_relevant(l2.var());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(solver.is_relevant(l2));
|
||||
SASSERT(!solver.is_relevant(l3));
|
||||
|
||||
solver.pop_scope(1);
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(!solver.is_relevant(l3));
|
||||
}
|
||||
|
||||
static void tst7() {
|
||||
sat_solver<relevancy_extension> solver;
|
||||
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_var();
|
||||
literal l3 = solver.mk_or(l1, l2);
|
||||
|
||||
solver.push_scope();
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(!solver.is_relevant(l3));
|
||||
|
||||
solver.mark_as_relevant(l3.var());
|
||||
solver.assign(l3, mk_axiom());
|
||||
solver.assign(l2, mk_axiom());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(solver.is_relevant(l2));
|
||||
SASSERT(solver.is_relevant(l3));
|
||||
|
||||
solver.assign(l1, mk_axiom());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(solver.is_relevant(l2));
|
||||
SASSERT(solver.is_relevant(l3));
|
||||
|
||||
solver.pop_scope(1);
|
||||
solver.propagate();
|
||||
solver.push_scope();
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(!solver.is_relevant(l3));
|
||||
|
||||
solver.mark_as_relevant(l3.var());
|
||||
solver.assign(l3, mk_axiom());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(solver.is_relevant(l3));
|
||||
|
||||
solver.assign(l1, mk_axiom());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(solver.is_relevant(l3));
|
||||
|
||||
solver.assign(l2, mk_axiom());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(solver.is_relevant(l3));
|
||||
|
||||
solver.pop_scope(1);
|
||||
solver.propagate();
|
||||
solver.push_scope();
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(!solver.is_relevant(l3));
|
||||
|
||||
solver.assign(~l3, mk_axiom());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(!solver.is_relevant(l3));
|
||||
|
||||
solver.mark_as_relevant(l3.var());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.is_relevant(l1));
|
||||
SASSERT(solver.is_relevant(l2));
|
||||
SASSERT(solver.is_relevant(l3));
|
||||
|
||||
solver.pop_scope(1);
|
||||
solver.propagate();
|
||||
solver.push_scope();
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(!solver.is_relevant(l3));
|
||||
|
||||
solver.mark_as_relevant(l3.var());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(solver.is_relevant(l3));
|
||||
|
||||
solver.assign(~l3, mk_axiom());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.is_relevant(l1));
|
||||
SASSERT(solver.is_relevant(l2));
|
||||
SASSERT(solver.is_relevant(l3));
|
||||
}
|
||||
|
||||
static void tst8() {
|
||||
sat_solver<relevancy_extension> solver;
|
||||
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_var();
|
||||
literal l3 = solver.mk_or(l1, l2);
|
||||
|
||||
solver.push_scope();
|
||||
|
||||
solver.mark_as_relevant(l3.var());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(solver.is_relevant(l3));
|
||||
|
||||
solver.assign(l1, mk_axiom());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(solver.is_relevant(l3));
|
||||
|
||||
solver.assign(l2, mk_axiom());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(solver.is_relevant(l3));
|
||||
|
||||
solver.pop_scope(1);
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(!solver.is_relevant(l3));
|
||||
}
|
||||
|
||||
static void tst9() {
|
||||
sat_solver<relevancy_extension> solver;
|
||||
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_var();
|
||||
literal l3 = solver.mk_or(l1, l2);
|
||||
|
||||
solver.mark_as_relevant(l3.var());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(solver.is_relevant(l3));
|
||||
|
||||
solver.assign(l1, mk_axiom());
|
||||
solver.assign(l2, mk_axiom());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.is_relevant(l1) || solver.is_relevant(l2));
|
||||
SASSERT(solver.is_relevant(l1) != solver.is_relevant(l2));
|
||||
SASSERT(solver.is_relevant(l3));
|
||||
}
|
||||
|
||||
static void tst10() {
|
||||
sat_solver<relevancy_extension> solver;
|
||||
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_var();
|
||||
literal l3 = solver.mk_or(l1, l2);
|
||||
|
||||
solver.assign(l1, mk_axiom());
|
||||
solver.assign(l2, mk_axiom());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(!solver.is_relevant(l3));
|
||||
|
||||
solver.mark_as_relevant(l3.var());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.is_relevant(l1) || solver.is_relevant(l2));
|
||||
SASSERT(solver.is_relevant(l1) != solver.is_relevant(l2));
|
||||
SASSERT(solver.is_relevant(l3));
|
||||
}
|
||||
|
||||
static void tst11() {
|
||||
sat_solver<relevancy_extension> solver;
|
||||
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_var();
|
||||
literal l3 = solver.mk_iff(l1, l2);
|
||||
literal l4 = solver.mk_var();
|
||||
literal l5 = solver.mk_or(l3, l4);
|
||||
|
||||
solver.propagate();
|
||||
solver.push_scope();
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(!solver.is_relevant(l3));
|
||||
SASSERT(!solver.is_relevant(l4));
|
||||
SASSERT(!solver.is_relevant(l5));
|
||||
|
||||
solver.assign(l3, mk_axiom());
|
||||
solver.mark_as_relevant(l5.var());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.is_relevant(l1));
|
||||
SASSERT(solver.is_relevant(l2));
|
||||
SASSERT(solver.is_relevant(l3));
|
||||
SASSERT(!solver.is_relevant(l4));
|
||||
SASSERT(solver.is_relevant(l5));
|
||||
|
||||
solver.assign(l4, mk_axiom());
|
||||
solver.propagate();
|
||||
SASSERT(!solver.is_relevant(l4));
|
||||
|
||||
solver.pop_scope(1);
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(!solver.is_relevant(l3));
|
||||
SASSERT(!solver.is_relevant(l4));
|
||||
SASSERT(!solver.is_relevant(l5));
|
||||
|
||||
solver.assign(l4, mk_axiom());
|
||||
solver.mark_as_relevant(l5.var());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(!solver.is_relevant(l3));
|
||||
SASSERT(solver.is_relevant(l4));
|
||||
SASSERT(solver.is_relevant(l5));
|
||||
|
||||
solver.assign(l1, mk_axiom());
|
||||
solver.assign(l2, mk_axiom());
|
||||
solver.assign(l3, mk_axiom());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
SASSERT(!solver.is_relevant(l3));
|
||||
SASSERT(solver.is_relevant(l4));
|
||||
SASSERT(solver.is_relevant(l5));
|
||||
}
|
||||
|
||||
static void tst12(clause_kind k) {
|
||||
sat_solver<relevancy_extension> solver;
|
||||
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_var();
|
||||
|
||||
solver.mk_aux_clause(l1, l2, k);
|
||||
|
||||
solver.push_scope();
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
|
||||
solver.assign(l1, mk_axiom());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
|
||||
solver.assign(l2, mk_axiom());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
|
||||
solver.pop_scope(1);
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
}
|
||||
|
||||
static void tst13(clause_kind k) {
|
||||
sat_solver<relevancy_extension> solver;
|
||||
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_var();
|
||||
|
||||
solver.mk_aux_clause(l1, l2, k);
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
|
||||
solver.assign(l1, mk_axiom());
|
||||
solver.assign(l2, mk_axiom());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
SASSERT(!solver.is_relevant(l2));
|
||||
}
|
||||
|
||||
static void tst14() {
|
||||
sat_solver<relevancy_extension> solver;
|
||||
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_var();
|
||||
|
||||
solver.push_scope();
|
||||
|
||||
solver.assign(l1, mk_axiom());
|
||||
|
||||
solver.mk_aux_clause(l1, l2, CLS_MAIN);
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.is_relevant(l1));
|
||||
}
|
||||
|
||||
static void tst15() {
|
||||
sat_solver<relevancy_extension> solver;
|
||||
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_var();
|
||||
|
||||
solver.push_scope();
|
||||
|
||||
solver.assign(l1, mk_axiom());
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(!solver.is_relevant(l1));
|
||||
|
||||
solver.push_scope();
|
||||
|
||||
solver.mk_aux_clause(l1, l2, CLS_MAIN);
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.is_relevant(l1));
|
||||
|
||||
solver.pop_scope(1);
|
||||
solver.propagate();
|
||||
|
||||
SASSERT(solver.is_relevant(l1));
|
||||
}
|
||||
|
||||
static void tst16() {
|
||||
sat_solver<relevancy_extension> solver;
|
||||
|
||||
literal l1 = solver.mk_var();
|
||||
|
||||
solver.push_scope();
|
||||
solver.assert_lit(l1);
|
||||
solver.propagate();
|
||||
SASSERT(solver.is_relevant(l1));
|
||||
SASSERT(solver.get_assignment(l1) == l_true);
|
||||
solver.assert_lit(l1);
|
||||
solver.pop_scope(1);
|
||||
SASSERT(solver.get_assignment(l1) == l_true);
|
||||
SASSERT(solver.is_relevant(l1));
|
||||
}
|
||||
|
||||
static void tst17() {
|
||||
sat_solver<relevancy_extension> solver;
|
||||
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_var();
|
||||
solver.assert_nonrelevant_lit(l1);
|
||||
solver.mk_aux_clause(l1, l2, CLS_MAIN);
|
||||
solver.check();
|
||||
SASSERT(solver.get_assignment(l1) == l_true || solver.get_assignment(l2) == l_true);
|
||||
SASSERT(solver.is_relevant(l1) || solver.is_relevant(l2));
|
||||
}
|
||||
|
||||
static void tst18() {
|
||||
sat_solver<relevancy_extension> solver;
|
||||
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_var();
|
||||
solver.assert_nonrelevant_lit(l1);
|
||||
literal l3 = solver.mk_or(l1, l2);
|
||||
SASSERT(l3 != true_literal);
|
||||
solver.assert_lit(l3);
|
||||
lbool r = solver.check();
|
||||
SASSERT(r == l_true);
|
||||
SASSERT(solver.is_relevant(l3));
|
||||
SASSERT(solver.is_relevant(l1));
|
||||
}
|
||||
|
||||
public:
|
||||
|
||||
static void run_tests() {
|
||||
tst1();
|
||||
tst2();
|
||||
tst3();
|
||||
tst4();
|
||||
tst5();
|
||||
tst6();
|
||||
tst7();
|
||||
tst8();
|
||||
tst9();
|
||||
tst10();
|
||||
tst11();
|
||||
tst12(CLS_MAIN);
|
||||
tst12(CLS_TRANSIENT);
|
||||
tst13(CLS_AUXILIARY);
|
||||
tst13(CLS_EXT_LEMMA);
|
||||
tst13(CLS_EXTERNAL);
|
||||
tst14();
|
||||
tst15();
|
||||
tst16();
|
||||
tst17();
|
||||
tst18();
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
void tst_relevancy() {
|
||||
sat_relevancy_tester::run_tests();
|
||||
}
|
||||
389
src/test/dead/sat.cpp
Normal file
389
src/test/dead/sat.cpp
Normal file
|
|
@ -0,0 +1,389 @@
|
|||
/*++
|
||||
Copyright (c) 2006 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
tst_sat.cpp
|
||||
|
||||
Abstract:
|
||||
|
||||
Test SAT solver
|
||||
|
||||
Author:
|
||||
|
||||
Leonardo de Moura (leonardo) 2006-10-05.
|
||||
|
||||
Revision History:
|
||||
|
||||
--*/
|
||||
|
||||
#include"sat_def.h"
|
||||
|
||||
class sat_tester {
|
||||
|
||||
static void tst1() {
|
||||
sat_solver<no_extension> solver;
|
||||
solver.push_user_scope();
|
||||
solver.push_scope();
|
||||
literal l1 = solver.mk_var();
|
||||
SASSERT(solver.m_ref_count[l1.var()] == 1);
|
||||
solver.assert_lit(l1);
|
||||
SASSERT(solver.m_ref_count[l1.var()] == 2);
|
||||
SASSERT(solver.m_weak_ref_count[l1.var()] == 1);
|
||||
SASSERT(solver.get_assignment(l1) == l_true);
|
||||
SASSERT(solver.m_level[l1.var()] == 1);
|
||||
literal l2 = solver.mk_var();
|
||||
SASSERT(solver.m_ref_count[l2.var()] == 1);
|
||||
SASSERT(solver.get_assignment(l2) == l_undef);
|
||||
SASSERT(solver.m_level.size() == 3);
|
||||
SASSERT(solver.m_free_var_indices.size() == 0);
|
||||
solver.pop_scope(1);
|
||||
SASSERT(solver.m_free_var_indices.size() == 2);
|
||||
SASSERT(solver.m_ref_count[l1.var()] == 0);
|
||||
}
|
||||
|
||||
template<typename Ext>
|
||||
static void tst2() {
|
||||
sat_solver<Ext> solver;
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_var();
|
||||
literal l3 = solver.mk_var();
|
||||
literal l4 = solver.mk_var();
|
||||
solver.mk_aux_clause(~l1, ~l2, l3, CLS_MAIN);
|
||||
solver.mk_aux_clause(~l3, ~l4, CLS_MAIN);
|
||||
solver.push_scope();
|
||||
solver.assign(l1, mk_axiom());
|
||||
solver.assign(l2, mk_axiom());
|
||||
SASSERT(solver.get_assignment(l3) == l_undef);
|
||||
SASSERT(solver.get_assignment(l4) == l_undef);
|
||||
solver.propagate();
|
||||
SASSERT(solver.get_assignment(l3) == l_true);
|
||||
SASSERT(solver.get_assignment(l4) == l_false);
|
||||
solver.pop_scope(1);
|
||||
SASSERT(solver.get_assignment(l1) == l_undef);
|
||||
SASSERT(solver.get_assignment(l2) == l_undef);
|
||||
SASSERT(solver.get_assignment(l3) == l_undef);
|
||||
SASSERT(solver.get_assignment(l4) == l_undef);
|
||||
}
|
||||
|
||||
static void tst3() {
|
||||
sat_solver<no_extension> solver;
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_var();
|
||||
solver.push_scope();
|
||||
SASSERT(solver.m_ref_count[l1.var()] == 1);
|
||||
solver.mk_aux_clause(~l1, l2, CLS_TRANSIENT);
|
||||
SASSERT(solver.m_ref_count[l1.var()] == 2);
|
||||
solver.assign(l1, mk_axiom());
|
||||
solver.propagate();
|
||||
SASSERT(solver.get_assignment(l2) == l_true);
|
||||
SASSERT(solver.m_transient_clauses.size() == 1);
|
||||
TRACE("sat_ext", tout << "ref_count: " << solver.m_ref_count[l1.var()] << ", scope_lvl: " << solver.m_scope_lvl << "\n";);
|
||||
SASSERT(solver.m_ref_count[l1.var()] == 3);
|
||||
SASSERT(solver.m_ref_count[l2.var()] == 3);
|
||||
solver.pop_scope(1);
|
||||
solver.assign(l1, mk_axiom());
|
||||
solver.propagate();
|
||||
SASSERT(solver.get_assignment(l2) == l_undef);
|
||||
SASSERT(solver.m_transient_clauses.size() == 0);
|
||||
SASSERT(solver.m_ref_count[l1.var()] == 2);
|
||||
SASSERT(solver.m_ref_count[l2.var()] == 1);
|
||||
}
|
||||
|
||||
static void tst4() {
|
||||
sat_solver<no_extension> solver;
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_var();
|
||||
literal l3 = solver.mk_var();
|
||||
literal l4 = solver.mk_var();
|
||||
solver.push_user_scope();
|
||||
solver.mk_aux_clause(~l1, l2, l4, CLS_MAIN);
|
||||
solver.push_user_scope();
|
||||
solver.mk_aux_clause(~l1, ~l2, l3, CLS_MAIN);
|
||||
solver.push_scope();
|
||||
solver.mk_aux_clause(~l3, ~l4, CLS_TRANSIENT);
|
||||
solver.mk_aux_clause(~l1, ~l4, CLS_MAIN);
|
||||
SASSERT(solver.m_ref_count[l1.var()] == 4);
|
||||
SASSERT(solver.m_ref_count[l2.var()] == 3);
|
||||
SASSERT(solver.m_ref_count[l3.var()] == 3);
|
||||
SASSERT(solver.m_ref_count[l4.var()] == 4);
|
||||
SASSERT(solver.m_main_clauses.size() == 3);
|
||||
SASSERT(solver.m_transient_clauses.size() == 1);
|
||||
solver.pop_scope(2);
|
||||
SASSERT(solver.m_ref_count[l1.var()] == 2);
|
||||
SASSERT(solver.m_ref_count[l2.var()] == 2);
|
||||
SASSERT(solver.m_ref_count[l3.var()] == 1);
|
||||
SASSERT(solver.m_ref_count[l4.var()] == 2);
|
||||
SASSERT(solver.m_main_clauses.size() == 1);
|
||||
SASSERT(solver.m_transient_clauses.size() == 0);
|
||||
solver.assign(l1, mk_axiom());
|
||||
SASSERT(solver.get_assignment(l4) == l_undef);
|
||||
solver.pop_scope(1);
|
||||
SASSERT(solver.m_main_clauses.size() == 0);
|
||||
SASSERT(solver.m_ref_count[l1.var()] == 1);
|
||||
SASSERT(solver.m_ref_count[l2.var()] == 1);
|
||||
SASSERT(solver.m_ref_count[l3.var()] == 1);
|
||||
SASSERT(solver.m_ref_count[l4.var()] == 1);
|
||||
}
|
||||
|
||||
template<typename Ext>
|
||||
static void tst5() {
|
||||
sat_solver<Ext> solver;
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_var();
|
||||
solver.push_scope();
|
||||
solver.assign(l1, mk_axiom());
|
||||
solver.push_scope();
|
||||
solver.mk_aux_clause(~l1, l2, CLS_MAIN);
|
||||
SASSERT(solver.get_assignment(l2) == l_true);
|
||||
solver.pop_scope(1);
|
||||
SASSERT(solver.get_assignment(l2) == l_true);
|
||||
solver.pop_scope(1);
|
||||
SASSERT(solver.get_assignment(l2) == l_undef);
|
||||
SASSERT(solver.m_main_clauses.size() == 1);
|
||||
}
|
||||
|
||||
static void tst6() {
|
||||
sat_solver<no_extension> solver;
|
||||
|
||||
literal l = solver.mk_var();
|
||||
solver.assert_lit(l);
|
||||
SASSERT(!solver.inconsistent());
|
||||
solver.push_scope();
|
||||
solver.assign(~l, mk_axiom());
|
||||
SASSERT(solver.inconsistent());
|
||||
solver.pop_scope(1);
|
||||
SASSERT(!solver.inconsistent());
|
||||
}
|
||||
|
||||
class no_ref_count : public no_extension {
|
||||
public:
|
||||
static bool ref_counters_enabled() {
|
||||
return false;
|
||||
}
|
||||
};
|
||||
|
||||
static void tst7() {
|
||||
sat_solver<no_ref_count> solver;
|
||||
literal l1 = solver.mk_var();
|
||||
solver.push_user_scope();
|
||||
literal l2 = solver.mk_var();
|
||||
SASSERT(solver.get_var_vector_size() == 3);
|
||||
solver.pop_scope(1);
|
||||
SASSERT(solver.get_var_vector_size() == 2);
|
||||
}
|
||||
|
||||
static void tst8() {
|
||||
literal l[2];
|
||||
l[0] = true_literal;
|
||||
l[1] = true_literal;
|
||||
clause * cls = clause::mk_clause(2, l, CLS_EXTERNAL);
|
||||
SASSERT(cls->kind() == CLS_EXTERNAL);
|
||||
dealloc(cls);
|
||||
}
|
||||
|
||||
static void tst9() {
|
||||
sat_solver<no_extension> solver;
|
||||
|
||||
solver.push_scope();
|
||||
literal l1 = solver.mk_var();
|
||||
literal l2 = solver.mk_var();
|
||||
literal l3 = solver.mk_var();
|
||||
solver.mk_aux_clause(l1, l2, l3, CLS_MAIN);
|
||||
solver.pop_scope(1);
|
||||
SASSERT(solver.m_ref_count[l1.var()] == 1);
|
||||
SASSERT(solver.get_assignment(l1) == l_undef);
|
||||
solver.assert_lit(~l2);
|
||||
solver.assert_lit(~l3);
|
||||
solver.propagate();
|
||||
SASSERT(solver.get_assignment(l1) == l_true);
|
||||
SASSERT(solver.m_main_clauses.size() == 1);
|
||||
SASSERT(solver.m_ref_count[l1.var()] == 2);
|
||||
solver.simplify_clauses();
|
||||
SASSERT(solver.m_main_clauses.size() == 0);
|
||||
SASSERT(solver.m_ref_count[l1.var()] == 1);
|
||||
SASSERT(solver.m_weak_ref_count[l1.var()] == 1);
|
||||
SASSERT(solver.get_assignment(l1) == l_true);
|
||||
}
|
||||
|
||||
static void tst10() {
|
||||
sat_solver<no_extension> s;
|
||||
|
||||
literal l1 = s.mk_var();
|
||||
literal l2 = s.mk_var();
|
||||
literal l3 = s.mk_var();
|
||||
|
||||
s.push_scope();
|
||||
s.assign(l1, mk_axiom());
|
||||
s.push_scope();
|
||||
literal l4 = s.mk_var();
|
||||
s.assign(l4, mk_axiom());
|
||||
s.mk_aux_clause(~l4, l3, CLS_TRANSIENT);
|
||||
s.mk_aux_clause(~l4, l2, CLS_TRANSIENT);
|
||||
s.mk_aux_clause(~l3, ~l1, ~l2, CLS_TRANSIENT);
|
||||
SASSERT(s.inconsistent());
|
||||
#ifdef Z3DEBUG
|
||||
bool r =
|
||||
#endif
|
||||
s.resolve_conflict();
|
||||
SASSERT(r);
|
||||
SASSERT(s.m_scope_lvl == 1);
|
||||
SASSERT(s.m_ref_count[l4.var()] > 0);
|
||||
s.pop_scope(1);
|
||||
SASSERT(s.get_assignment(l1) == l_undef);
|
||||
SASSERT(s.get_assignment(l4) == l_undef);
|
||||
s.push_scope();
|
||||
s.assign(l4, mk_axiom());
|
||||
#ifdef Z3DEBUG
|
||||
s.del_learned_clauses();
|
||||
#endif
|
||||
s.pop_scope(1);
|
||||
}
|
||||
|
||||
static void tst11() {
|
||||
// out-of-order conflict bug.
|
||||
sat_solver<no_extension> s;
|
||||
|
||||
literal l1 = s.mk_var();
|
||||
literal l2 = s.mk_var();
|
||||
s.push_scope();
|
||||
s.assign(l1, mk_axiom());
|
||||
s.assign(l2, mk_axiom());
|
||||
s.push_scope();
|
||||
s.mk_aux_clause(~l1, ~l2, CLS_TRANSIENT);
|
||||
s.propagate();
|
||||
s.resolve_conflict();
|
||||
}
|
||||
|
||||
static void tst12() {
|
||||
// out-of-order conflict bug.
|
||||
sat_solver<no_extension> s;
|
||||
|
||||
literal l1 = s.mk_var();
|
||||
literal l2 = s.mk_var();
|
||||
literal l3 = s.mk_var();
|
||||
s.push_scope();
|
||||
s.assign(l1, mk_axiom());
|
||||
s.assign(l2, mk_axiom());
|
||||
s.push_scope();
|
||||
s.assign(l3, mk_axiom());
|
||||
s.mk_aux_clause(~l1, ~l2, CLS_TRANSIENT);
|
||||
s.propagate();
|
||||
s.resolve_conflict();
|
||||
}
|
||||
|
||||
static void tst13() {
|
||||
sat_solver<no_extension> s;
|
||||
literal l1 = s.mk_var();
|
||||
literal l2 = s.mk_var();
|
||||
literal l3 = s.mk_var();
|
||||
s.push_scope();
|
||||
s.assign(l1, mk_axiom());
|
||||
s.push_scope();
|
||||
s.assign(l2, mk_axiom());
|
||||
s.push_scope();
|
||||
s.mk_aux_clause(~l1, l3, CLS_MAIN);
|
||||
s.propagate();
|
||||
SASSERT(!s.inconsistent());
|
||||
SASSERT(s.get_assignment(l3) == l_true);
|
||||
s.mk_aux_clause(~l1, ~l2, CLS_TRANSIENT);
|
||||
s.propagate();
|
||||
SASSERT(s.inconsistent());
|
||||
#ifdef Z3DEBUG
|
||||
bool r =
|
||||
#endif
|
||||
s.resolve_conflict();
|
||||
SASSERT(r);
|
||||
SASSERT(s.get_assignment(l3) == l_true);
|
||||
TRACE("sat", tout << l3 << " : " << s.get_assignment(l3) << " : " << s.m_level[l3.var()] << " : " << s.m_scope_lvl << "\n";);
|
||||
}
|
||||
|
||||
static void tst14() {
|
||||
sat_solver<no_extension> s;
|
||||
literal l1 = s.mk_var();
|
||||
literal l2 = s.mk_var();
|
||||
s.push_scope();
|
||||
s.assign(~l1, mk_axiom());
|
||||
s.push_scope();
|
||||
s.assign(~l2, mk_axiom());
|
||||
s.assert_lit(l1);
|
||||
SASSERT(s.inconsistent());
|
||||
#ifdef Z3DEBUG
|
||||
bool r =
|
||||
#endif
|
||||
s.resolve_conflict();
|
||||
SASSERT(r);
|
||||
SASSERT(s.get_assignment(l1) == l_true);
|
||||
}
|
||||
|
||||
static void tst15() {
|
||||
sat_solver<no_extension> s;
|
||||
literal l1 = s.mk_var();
|
||||
literal l2 = s.mk_var();
|
||||
s.push_scope();
|
||||
s.assign(~l1, mk_axiom());
|
||||
s.push_scope();
|
||||
s.assign(~l2, mk_axiom());
|
||||
s.assert_lit(l1);
|
||||
SASSERT(s.inconsistent());
|
||||
#ifdef Z3DEBUG
|
||||
bool r =
|
||||
#endif
|
||||
s.resolve_conflict();
|
||||
SASSERT(r);
|
||||
SASSERT(s.get_assignment(l1) == l_true);
|
||||
}
|
||||
|
||||
static void tst16() {
|
||||
sat_solver<no_extension> s;
|
||||
s.push_scope();
|
||||
literal l1 = s.mk_var();
|
||||
bool_var v1 = l1.var();
|
||||
s.inc_weak_ref(v1);
|
||||
s.pop_scope(1);
|
||||
SASSERT(s.get_ref_count(v1) == 0);
|
||||
literal l2 = s.mk_var();
|
||||
SASSERT(l2.var() != v1);
|
||||
s.dec_weak_ref(v1);
|
||||
literal l3 = s.mk_var();
|
||||
SASSERT(l3.var() == v1);
|
||||
}
|
||||
|
||||
public:
|
||||
static void run_tests() {
|
||||
enable_trace("sat_ext");
|
||||
enable_trace("backtrack");
|
||||
enable_trace("mk_clause");
|
||||
enable_debug("mk_clause");
|
||||
enable_trace("propagate");
|
||||
enable_trace("simplify");
|
||||
enable_trace("del_learned_clauses");
|
||||
enable_debug("sat_invariant");
|
||||
TRACE("sat_ext", tout << "running SAT solver tests...\n";);
|
||||
tst1();
|
||||
tst2<no_extension>();
|
||||
tst2<no_ref_count>();
|
||||
tst3();
|
||||
tst4();
|
||||
tst5<no_extension>();
|
||||
tst5<no_ref_count>();
|
||||
tst6();
|
||||
tst7();
|
||||
tst8();
|
||||
tst9();
|
||||
tst10();
|
||||
tst11();
|
||||
tst12();
|
||||
tst13();
|
||||
tst14();
|
||||
tst15();
|
||||
tst16();
|
||||
}
|
||||
};
|
||||
|
||||
void tst_sat() {
|
||||
TRACE("sat", tout << "sizeof(clause): " << sizeof(clause) << "\n";);
|
||||
sat_tester::run_tests();
|
||||
}
|
||||
|
||||
|
||||
45
src/test/dead/simplex_polynomial.cpp
Normal file
45
src/test/dead/simplex_polynomial.cpp
Normal file
|
|
@ -0,0 +1,45 @@
|
|||
#include "simplex_polynomial.h"
|
||||
|
||||
void tst_simplex_polynomial()
|
||||
{
|
||||
polynomial p1, p2, p3, p4;
|
||||
simplex_variable v1(1), v2(2), v3(3), v4(4), v5(5);
|
||||
monomial m1(v1), m2(v2), m3(v3), m4(v4);
|
||||
|
||||
m1 = monomial(v1);
|
||||
m1 *= monomial(v2);
|
||||
m1 *= monomial(v1);
|
||||
|
||||
m1.display(std::cout) << std::endl;
|
||||
m1.normalize();
|
||||
m1.display(std::cout) << std::endl;
|
||||
|
||||
m2 = m1;
|
||||
SASSERT(m1 == m2);
|
||||
|
||||
p1 = polynomial(rational(1,2));
|
||||
SASSERT(p1.is_const());
|
||||
|
||||
p1 += polynomial(v1);
|
||||
SASSERT(!p1.is_const());
|
||||
|
||||
p1 += polynomial(v2);
|
||||
p1 *= polynomial(v2);
|
||||
p1 -= polynomial(v3);
|
||||
p1 += polynomial(rational(2,3));
|
||||
|
||||
p1.normalize();
|
||||
p1.display(std::cout) << std::endl;
|
||||
SASSERT(p1[0].size() == 0); // first element is a constant.
|
||||
|
||||
|
||||
p1 = polynomial(v1);
|
||||
p2 = polynomial(v2);
|
||||
p3 = polynomial(v3);
|
||||
p3 += p2;
|
||||
p3 *= p1;
|
||||
|
||||
p3.display(std::cout) << std::endl; // multiplication distributes.
|
||||
SASSERT(p3.size() == 2);
|
||||
|
||||
}
|
||||
101
src/test/dead/template_models.cpp
Normal file
101
src/test/dead/template_models.cpp
Normal file
|
|
@ -0,0 +1,101 @@
|
|||
#include "ast_fm.h"
|
||||
#include "smtparser.h"
|
||||
#include "ast_pp.h"
|
||||
|
||||
static void
|
||||
simplify_formula(
|
||||
ast_manager& ast_manager,
|
||||
smtlib::symtable* table,
|
||||
smtlib::parser* parser,
|
||||
ast* formula
|
||||
)
|
||||
{
|
||||
// front_end_params params;
|
||||
// std::cout << std::make_pair(&ast_manager, formula) << std::endl;
|
||||
|
||||
// const_decl_ast *le_decl = 0, *add_decl = 0, *mul_decl = 0;
|
||||
// const_decl_ast *lt_decl = 0, *gt_decl = 0, *f_decl = 0;
|
||||
// type_decl_ast* int_decl = 0;
|
||||
// type_ast* int_type = 0;
|
||||
|
||||
// table->find1("<=", le_decl);
|
||||
// table->find1("+", add_decl);
|
||||
// table->find1("*", mul_decl);
|
||||
// table->find1("f", f_decl);
|
||||
// table->find1("<", lt_decl);
|
||||
// table->find1(">", gt_decl);
|
||||
// table->find("Int", int_decl);
|
||||
// int_type = ast_manager.mk_type(int_decl);
|
||||
|
||||
|
||||
// ast_simplifier simplifier(ast_manager, params);
|
||||
|
||||
// #if 0
|
||||
// iast_arith_simplifier* arith =
|
||||
// simplifier.add_arithmetic(
|
||||
// null_theory_id, // TBD
|
||||
// add_decl,
|
||||
// mul_decl,
|
||||
// le_decl,
|
||||
// false
|
||||
// );
|
||||
|
||||
// arith->register_lt(lt_decl);
|
||||
// arith->register_gt(gt_decl);
|
||||
// #endif
|
||||
// ast_fm fm(ast_manager, simplifier, le_decl, add_decl, mul_decl);
|
||||
|
||||
// ast_function_replace replace(ast_manager);
|
||||
|
||||
// ast_ref<> templ(ast_manager);
|
||||
// templ = ast_manager.mk_const(add_decl,
|
||||
// ast_manager.mk_var(0,int_type),
|
||||
// ast_manager.mk_numeral(rational(2), int_type));
|
||||
|
||||
// ast_ref<> result(ast_manager);
|
||||
|
||||
// //
|
||||
// // Replace f by \lambda x . x + 2 in formula.
|
||||
// //
|
||||
|
||||
// replace(formula, f_decl, 1, templ.get(), result);
|
||||
|
||||
// std::cout << "substituted:"
|
||||
// << std::make_pair(&ast_manager, result.get()) << std::endl;
|
||||
|
||||
// //
|
||||
// // Eliminate quantified variables from the formula.
|
||||
// //
|
||||
// fm.eliminate(result.get(), result);
|
||||
|
||||
// std::cout << "projected:"
|
||||
// << std::make_pair(&ast_manager, result.get()) << std::endl;
|
||||
|
||||
}
|
||||
|
||||
void tst_template_models()
|
||||
{
|
||||
const char* spec =
|
||||
"(benchmark template_models :logic QF_LIA \n"
|
||||
":extrafuns ((f Int Int) (b Int) (c Int))\n"
|
||||
":formula (forall (x Int) (and (< (f x) (f (+ x 1))) (> (f b) b) (> (f c) b))))";
|
||||
|
||||
ast_manager ast_manager;
|
||||
smtlib::parser* parser = smtlib::parser::create(ast_manager);
|
||||
|
||||
parser->initialize_smtlib();
|
||||
|
||||
parser->parse_string(spec);
|
||||
|
||||
smtlib::benchmark* b = parser->get_benchmark();
|
||||
|
||||
smtlib::symtable* table = b->get_symtable();
|
||||
vector<smtlib::formula,false> formulas;
|
||||
b->get_formulas(formulas);
|
||||
for (unsigned j = 0; j < formulas.size(); ++j) {
|
||||
simplify_formula(ast_manager, table,
|
||||
parser, formulas[j].m_formula);
|
||||
}
|
||||
|
||||
dealloc(parser);
|
||||
}
|
||||
65
src/test/dead/th_propagation.cpp
Normal file
65
src/test/dead/th_propagation.cpp
Normal file
|
|
@ -0,0 +1,65 @@
|
|||
/*++
|
||||
Copyright (c) 2006 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
th_propagation.cpp
|
||||
|
||||
Abstract:
|
||||
|
||||
Test theory propagation.
|
||||
|
||||
Author:
|
||||
|
||||
Leonardo de Moura (leonardo) 2006-11-07.
|
||||
|
||||
Revision History:
|
||||
|
||||
--*/
|
||||
#include"core_theory.h"
|
||||
|
||||
class th_propagation_tester {
|
||||
static void tst1() {
|
||||
core_theory t;
|
||||
t.m_params.m_relevancy_lvl = 0;
|
||||
|
||||
enode * n1 = t.mk_const();
|
||||
enode * n2 = t.mk_const();
|
||||
enode * n3 = t.mk_const();
|
||||
|
||||
literal eq1 = t.mk_eq(n1,n2);
|
||||
literal eq2 = t.mk_eq(n2,n3);
|
||||
literal eq3 = t.mk_eq(n1,n3);
|
||||
|
||||
literal l1 = t.mk_lit();
|
||||
literal l2 = t.mk_lit();
|
||||
t.mk_main_clause(l1, l2, ~eq3);
|
||||
t.mk_main_clause(~l2, ~eq3);
|
||||
t.mk_main_clause(~l1, ~eq2);
|
||||
|
||||
t.push_scope();
|
||||
t.assign(eq1, mk_axiom());
|
||||
t.propagate();
|
||||
|
||||
t.push_scope();
|
||||
t.assign(eq2, mk_axiom());
|
||||
t.propagate();
|
||||
SASSERT(t.get_assignment(eq3) == l_true);
|
||||
SASSERT(t.inconsistent());
|
||||
bool r = t.m_sat->resolve_conflict();
|
||||
SASSERT(r);
|
||||
}
|
||||
|
||||
public:
|
||||
static void run_tests() {
|
||||
enable_trace("th_prop");
|
||||
enable_trace("scope");
|
||||
enable_trace("conflict");
|
||||
tst1();
|
||||
}
|
||||
};
|
||||
|
||||
void tst_th_propagation() {
|
||||
th_propagation_tester::run_tests();
|
||||
}
|
||||
|
||||
42
src/test/dead/trail.cpp
Normal file
42
src/test/dead/trail.cpp
Normal file
|
|
@ -0,0 +1,42 @@
|
|||
/*++
|
||||
Copyright (c) 2006 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
trail.cpp
|
||||
|
||||
Abstract:
|
||||
|
||||
<abstract>
|
||||
|
||||
Author:
|
||||
|
||||
Leonardo de Moura (leonardo) 2007-02-26.
|
||||
|
||||
Revision History:
|
||||
|
||||
--*/
|
||||
#include"core_theory.h"
|
||||
|
||||
void tst_trail() {
|
||||
core_theory t;
|
||||
bvalue<int> v(10);
|
||||
t.push();
|
||||
v.set(t, 20);
|
||||
v.set(t, 30);
|
||||
SASSERT(v.get() == 30);
|
||||
t.pop(1);
|
||||
SASSERT(v.get() == 10);
|
||||
t.push();
|
||||
t.push();
|
||||
v.set(t, 100);
|
||||
SASSERT(v.get() == 100);
|
||||
t.pop(2);
|
||||
SASSERT(v.get() == 10);
|
||||
t.push();
|
||||
t.push();
|
||||
v.set(t, 40);
|
||||
SASSERT(v.get() == 40);
|
||||
t.pop(1);
|
||||
SASSERT(v.get() == 10);
|
||||
}
|
||||
89
src/test/dead/watch_list.cpp
Normal file
89
src/test/dead/watch_list.cpp
Normal file
|
|
@ -0,0 +1,89 @@
|
|||
/*++
|
||||
Copyright (c) 2006 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
tst_watch_list.cpp
|
||||
|
||||
Abstract:
|
||||
|
||||
Test watch list data structure.
|
||||
|
||||
Author:
|
||||
|
||||
Leonardo de Moura (leonardo) 2006-10-02.
|
||||
|
||||
Revision History:
|
||||
|
||||
--*/
|
||||
#include"vector.h"
|
||||
#include"sat_types.h"
|
||||
|
||||
static void tst1() {
|
||||
watch_list wl;
|
||||
for(unsigned i = 0; i < 10; i++)
|
||||
wl.insert_clause(reinterpret_cast<clause*>(static_cast<size_t>(i+1)));
|
||||
}
|
||||
|
||||
static void tst2() {
|
||||
ptr_vector<clause> clause_list;
|
||||
vector<literal> lit_list;
|
||||
watch_list wl;
|
||||
unsigned n = rand()%1000;
|
||||
for (unsigned i = 0; i < n; i++) {
|
||||
unsigned op = rand()%7;
|
||||
if (op <= 1) {
|
||||
clause * c = reinterpret_cast<clause*>(static_cast<size_t>(rand()));
|
||||
wl.insert_clause(c);
|
||||
clause_list.push_back(c);
|
||||
}
|
||||
else if (op <= 3) {
|
||||
literal l = to_literal(rand());
|
||||
wl.insert_literal(l);
|
||||
lit_list.push_back(l);
|
||||
}
|
||||
else if (op <= 4) {
|
||||
if (!clause_list.empty()) {
|
||||
int idx = rand() % (clause_list.size());
|
||||
clause * c = clause_list[idx];
|
||||
wl.remove_clause(c);
|
||||
ptr_vector<clause>::iterator it = std::find(clause_list.begin(), clause_list.end(), c);
|
||||
SASSERT(it);
|
||||
clause_list.erase(it);
|
||||
}
|
||||
}
|
||||
else if (op <= 5) {
|
||||
ptr_vector<clause>::iterator it = clause_list.begin();
|
||||
ptr_vector<clause>::iterator end = clause_list.end();
|
||||
watch_list::clause_iterator it2 = wl.begin_clause();
|
||||
watch_list::clause_iterator end2 = wl.end_clause();
|
||||
for (; it != end; ++it, ++it2) {
|
||||
SASSERT(it2 != end2);
|
||||
SASSERT(*it == *it2);
|
||||
}
|
||||
}
|
||||
else if (op <= 6) {
|
||||
vector<literal>::iterator begin = lit_list.begin();
|
||||
vector<literal>::iterator it = lit_list.end();
|
||||
watch_list::literal_iterator it2 = wl.begin_literals();
|
||||
watch_list::literal_iterator end2 = wl.end_literals();
|
||||
while (it != begin) {
|
||||
--it;
|
||||
SASSERT(it2 != end2);
|
||||
SASSERT(*it == *it2);
|
||||
++it2;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void tst3() {
|
||||
for (unsigned i = 0; i < 1000; i++)
|
||||
tst2();
|
||||
}
|
||||
|
||||
void tst_watch_list() {
|
||||
tst1();
|
||||
tst3();
|
||||
}
|
||||
|
||||
|
|
@ -1,118 +0,0 @@
|
|||
/*++
|
||||
Copyright (c) 2006 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
dl_rule_set.cpp
|
||||
|
||||
Abstract:
|
||||
|
||||
<abstract>
|
||||
|
||||
Author:
|
||||
|
||||
Leonardo de Moura (leonardo) 2010-05-18.
|
||||
|
||||
Revision History:
|
||||
|
||||
--*/
|
||||
#include"dl_context.h"
|
||||
#include"dl_rule_set.h"
|
||||
#include"dl_mk_filter_rules.h"
|
||||
#include"dl_mk_simple_joins.h"
|
||||
#include"smtparser.h"
|
||||
#include"ast_pp.h"
|
||||
#include<iostream>
|
||||
#include<sstream>
|
||||
|
||||
void tst_dl_rule_set() {
|
||||
enable_trace("mk_filter_rules");
|
||||
front_end_params params;
|
||||
ast_manager m;
|
||||
smtlib::parser * parser = smtlib::parser::create(m);
|
||||
parser->initialize_smtlib();
|
||||
datalog::context ctx(m, params);
|
||||
datalog::rule_set rs(ctx);
|
||||
datalog::rule_manager& rm = ctx.get_rule_manager();
|
||||
datalog::rule_ref_vector rv(rm);
|
||||
|
||||
|
||||
if (!parser->parse_string(
|
||||
"(benchmark test\n"
|
||||
":extrapreds ((T Int Int) (Q Int Int) (R Int Int Int) (S Int Int Int) (DynActual Int Int Int) (GlobalSym Int Int) (HeapPointsTo Int Int Int) (Calls Int Int)) \n"
|
||||
":extrapreds ((Actual Int Int Int) (PointsTo Int Int) (PointsTo0 Int Int) (FuncDecl0 Int Int) (Assign Int Int) (Load Int Int Int))\n"
|
||||
":formula (forall (x Int) (=> (Q x 1) (T x x)))\n"
|
||||
":formula (forall (v Int) (h Int) (=> (PointsTo0 v h) (PointsTo v h)))\n"
|
||||
":formula (forall (v Int) (h Int) (=> (FuncDecl0 v h) (PointsTo v h)))\n"
|
||||
":formula (forall (v Int) (h Int) (=> (FuncDecl0 v h) (PointsTo v h)))\n"
|
||||
":formula (forall (v1 Int) (v2 Int) (h Int) (=> (and (PointsTo v2 h) (Assign v1 v2)) (PointsTo v1 h)))\n"
|
||||
":formula (forall (x Int) (y Int) (z Int) (=> (and (Q x y) (T y z)) (T x y)))\n"
|
||||
":formula (forall (i1 Int) (v Int) (fun Int) (c Int) (v1 Int) (h Int) (h1 Int) (=> (and (GlobalSym 0 fun) (HeapPointsTo fun 1 c) (Calls i1 c) (Actual i1 3 v1) (PointsTo v1 h) (HeapPointsTo h 0 h1) (PointsTo v h1)) (DynActual i1 2 v)))\n"
|
||||
":formula (forall (i1 Int) (v Int) (fun Int) (c Int) (v1 Int) (h Int) (h1 Int) (=> (and (GlobalSym 0 fun) (HeapPointsTo fun 1 c) (Calls i1 c) (Actual i1 3 v1) (PointsTo v1 h) (HeapPointsTo h 1 h1) (PointsTo v h1)) (DynActual i1 3 v)))\n"
|
||||
":formula (forall (i1 Int) (v Int) (fun Int) (c Int) (v1 Int) (h Int) (h1 Int) (=> (and (GlobalSym 0 fun) (HeapPointsTo fun 1 c) (Calls i1 c) (Actual i1 3 v1) (PointsTo v1 h) (HeapPointsTo h 2 h1) (PointsTo v h1)) (DynActual i1 4 v)))\n"
|
||||
":formula (forall (v1 Int) (v2 Int) (h1 Int) (h2 Int) (f Int) (=> (and (Load v2 v1 f) (PointsTo v1 h1) (HeapPointsTo h1 f h2)) (PointsTo v2 h1)))\n"
|
||||
":formula (forall (v1 Int) (v2 Int) (h1 Int) (h2 Int) (f Int) (=> (and (Load v2 v1 0) (HeapPointsTo h1 f h2)) (PointsTo v2 h1)))\n"
|
||||
":formula (forall (v1 Int) (v2 Int) (h1 Int) (h2 Int) (f Int) (=> (and (not (Load v2 v1 0)) (HeapPointsTo h1 f h2)) (PointsTo v2 h1)))\n"
|
||||
")")) {
|
||||
SASSERT(false);
|
||||
dealloc(parser);
|
||||
return;
|
||||
}
|
||||
|
||||
smtlib::benchmark * b = parser->get_benchmark();
|
||||
|
||||
|
||||
for (unsigned j = 0; j < b->get_num_formulas(); ++j) {
|
||||
expr * e = b->begin_formulas()[j];
|
||||
ptr_vector<expr> todo;
|
||||
todo.push_back(e);
|
||||
while (!todo.empty()) {
|
||||
e = todo.back();
|
||||
todo.pop_back();
|
||||
if (is_quantifier(e)) {
|
||||
e = to_quantifier(e)->get_expr();
|
||||
todo.push_back(e);
|
||||
}
|
||||
else if (is_app(e)) {
|
||||
app* a = to_app(e);
|
||||
if (is_uninterp(e) && !ctx.is_predicate(a->get_decl())) {
|
||||
std::cout << "registering " << a->get_decl()->get_name() << "\n";
|
||||
|
||||
ctx.register_predicate(a->get_decl());
|
||||
}
|
||||
else {
|
||||
todo.append(a->get_num_args(), a->get_args());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
for (unsigned j = 0; j < b->get_num_formulas(); ++j) {
|
||||
expr * e = b->begin_formulas()[j];
|
||||
if (is_quantifier(e)) {
|
||||
try {
|
||||
rm.mk_rule(e, rv);
|
||||
}
|
||||
catch(...) {
|
||||
std::cerr << "ERROR: it is not a valid Datalog rule:\n" << mk_pp(e, m) << "\n";
|
||||
}
|
||||
}
|
||||
}
|
||||
rs.add_rules(rv.size(), rv.c_ptr());
|
||||
rs.display(std::cout);
|
||||
|
||||
datalog::mk_filter_rules p(ctx);
|
||||
model_converter_ref mc;
|
||||
proof_converter_ref pc;
|
||||
datalog::rule_set * new_rs = p(rs, mc, pc);
|
||||
std::cout << "\nAfter mk_filter:\n";
|
||||
new_rs->display(std::cout);
|
||||
datalog::mk_simple_joins p2(ctx);
|
||||
datalog::rule_set * new_rs2 = p2(*new_rs, mc, pc);
|
||||
std::cout << "\nAfter mk_simple_joins:\n";
|
||||
new_rs2->display(std::cout);
|
||||
dealloc(new_rs);
|
||||
dealloc(new_rs2);
|
||||
dealloc(parser);
|
||||
}
|
||||
|
|
@ -1,127 +0,0 @@
|
|||
#include "expr_delta.h"
|
||||
#include "smtparser.h"
|
||||
#include "ast_pp.h"
|
||||
#include "ast_smt_pp.h"
|
||||
|
||||
static void iterate_delta(ast_manager& m, expr_delta& delta) {
|
||||
unsigned n = 0;
|
||||
expr_ref_vector result(m);
|
||||
std::cout << "Delta\n";
|
||||
while (true) {
|
||||
result.reset();
|
||||
if (!delta.delta_dfs(n, result)) {
|
||||
return;
|
||||
}
|
||||
std::cout << n << ": ";
|
||||
for (unsigned i = 0; i < result.size(); ++i) {
|
||||
std::cout << mk_pp(result[i].get(), m) << " ";
|
||||
}
|
||||
std::cout << "\n";
|
||||
n++;
|
||||
}
|
||||
}
|
||||
|
||||
void tst_expr_delta1() {
|
||||
ast_manager m;
|
||||
smtlib::parser* parser = smtlib::parser::create(m);
|
||||
parser->initialize_smtlib();
|
||||
|
||||
parser->parse_string(
|
||||
"(benchmark samples :logic QF_LIA \n"
|
||||
" :extrafuns ((a Int) (b Int) (c Int)) \n"
|
||||
" :assumption (> a 0) \n"
|
||||
" :assumption (> b 0) \n"
|
||||
" :formula (forall (x Int) (y Int) (z Int) (and (<= 1 x) (<= x y))) \n"
|
||||
" :formula (forall (x Int) (y Int) (z Int) (and (<= 2 (ite (<= z 1) x (* 2 x))) (<= x y)))\n"
|
||||
" :formula (forall (x Int) (y Int) (and (<= 2 (ite (forall (z Int) (<= z 1)) x (* 2 x))) (<= x y)))\n"
|
||||
" :formula (forall (x Int) (y Int) (and (<= 2 (ite (forall (z Int) (or (> x y) (<= z 1))) x (* 2 x))) (<= x y)))\n"
|
||||
")"
|
||||
);
|
||||
|
||||
smtlib::benchmark* b = parser->get_benchmark();
|
||||
|
||||
for (unsigned j = 0; j < b->get_num_formulas(); ++j) {
|
||||
expr_delta delta(m);
|
||||
|
||||
for (unsigned i = 0; i < b->get_num_assumptions(); ++i) {
|
||||
delta.assert_cnstr(b->get_assumptions()[i]);
|
||||
}
|
||||
delta.assert_cnstr(b->begin_formulas()[j]);
|
||||
iterate_delta(m, delta);
|
||||
}
|
||||
|
||||
dealloc(parser);
|
||||
}
|
||||
|
||||
static void get_expr_delta(unsigned position, char const* in, char const* out) {
|
||||
ast_manager m;
|
||||
smtlib::parser* parser = smtlib::parser::create(m);
|
||||
parser->initialize_smtlib();
|
||||
|
||||
if (!parser->parse_file(in)) {
|
||||
std::cout << "error parsing file\n";
|
||||
dealloc(parser);
|
||||
return;
|
||||
}
|
||||
|
||||
smtlib::benchmark* b = parser->get_benchmark();
|
||||
|
||||
SASSERT(b->get_num_formulas() == 1);
|
||||
expr_delta delta(m);
|
||||
|
||||
for (unsigned i = 0; i < b->get_num_assumptions(); ++i) {
|
||||
delta.assert_cnstr(b->get_assumptions()[i]);
|
||||
}
|
||||
delta.assert_cnstr(b->begin_formulas()[0]);
|
||||
|
||||
|
||||
expr_ref_vector result(m);
|
||||
if (!delta.delta_dfs(position, result)) {
|
||||
std::cout << "done\n";
|
||||
}
|
||||
else {
|
||||
ast_smt_pp pp(m);
|
||||
std::ofstream outf(out);
|
||||
if (outf.bad() || outf.fail()) {
|
||||
std::cout << "Could not open output\n";
|
||||
}
|
||||
else {
|
||||
switch(b->get_status()) {
|
||||
case smtlib::benchmark::UNKNOWN:
|
||||
pp.set_status("unknown");
|
||||
break;
|
||||
case smtlib::benchmark::SAT:
|
||||
pp.set_status("sat");
|
||||
break;
|
||||
case smtlib::benchmark::UNSAT:
|
||||
pp.set_status("unsat");
|
||||
break;
|
||||
}
|
||||
pp.set_logic(b->get_logic().str().c_str());
|
||||
for (unsigned i = 0; i + 1 < result.size(); ++i) {
|
||||
pp.add_assumption(result[i].get());
|
||||
}
|
||||
pp.display(outf, result[result.size()-1].get());
|
||||
|
||||
std::cout << "ok\n";
|
||||
}
|
||||
}
|
||||
|
||||
dealloc(parser);
|
||||
}
|
||||
|
||||
void tst_expr_delta(char** argv, int argc, int& i) {
|
||||
if (i + 3 >= argc) {
|
||||
std::cout << "Usage: <position:number> <input:file-name> <output:file-name>\n";
|
||||
return;
|
||||
}
|
||||
++i;
|
||||
unsigned position = atol(argv[i]);
|
||||
++i;
|
||||
char const* in_file = argv[i];
|
||||
++i;
|
||||
char const* out_file = argv[i];
|
||||
|
||||
get_expr_delta(position, in_file, out_file);
|
||||
|
||||
}
|
||||
|
|
@ -1,51 +0,0 @@
|
|||
#include "expr_pattern_match.h"
|
||||
#include "smtparser.h"
|
||||
#include "ast_pp.h"
|
||||
#include "arith_decl_plugin.h"
|
||||
#include "bv_decl_plugin.h"
|
||||
#include "array_decl_plugin.h"
|
||||
#include "reg_decl_plugins.h"
|
||||
|
||||
void tst_expr_pattern_match() {
|
||||
ast_manager manager;
|
||||
reg_decl_plugins(manager);
|
||||
|
||||
expr_pattern_match apm(manager);
|
||||
|
||||
apm.display(std::cout);
|
||||
|
||||
const char* test_string = "(benchmark patterns :status unknown :logic ALL \n"
|
||||
":extrasorts (S) \n"
|
||||
":extrafuns ((R S S bool)) \n"
|
||||
":formula (forall (x S) (y S) (z S) \n"
|
||||
" (or (not (R x y)) (not (R y z)) (R x z)) \n"
|
||||
" ; :pats { (R x y) (R y z) } \n"
|
||||
" :weight { 2 } \n"
|
||||
" )\n"
|
||||
")";
|
||||
smtlib::parser* parser = smtlib::parser::create(manager);
|
||||
parser->initialize_smtlib();
|
||||
std::cout << "parsing test string\n";
|
||||
if (!parser->parse_string(test_string)) {
|
||||
UNREACHABLE();
|
||||
}
|
||||
std::cout << "test string parsed\n";
|
||||
smtlib::benchmark* bench = parser->get_benchmark();
|
||||
|
||||
for (unsigned i = 0; i < bench->get_num_formulas(); ++i) {
|
||||
expr* fml = bench->begin_formulas()[i];
|
||||
SASSERT(fml->get_kind() == AST_QUANTIFIER);
|
||||
quantifier* qf = to_quantifier(fml);
|
||||
app_ref_vector patterns(manager);
|
||||
unsigned weight = 0;
|
||||
if (apm.match_quantifier(qf, patterns, weight)) {
|
||||
std::cout << "Found pattern match\n";
|
||||
for (unsigned i = 0; i < patterns.size(); ++i) {
|
||||
ast_pp(std::cout, patterns[i].get(), manager) << "\n";
|
||||
}
|
||||
std::cout << "weight: " << weight << "\n";
|
||||
}
|
||||
}
|
||||
dealloc(parser);
|
||||
|
||||
}
|
||||
|
|
@ -1,94 +0,0 @@
|
|||
/*++
|
||||
Copyright (c) 2006 Microsoft Corporation
|
||||
|
||||
Module Name:
|
||||
|
||||
grobner.cpp
|
||||
|
||||
Abstract:
|
||||
|
||||
<abstract>
|
||||
|
||||
Author:
|
||||
|
||||
Leonardo de Moura (leonardo) 2008-12-05.
|
||||
|
||||
Revision History:
|
||||
|
||||
--*/
|
||||
#include"smtparser.h"
|
||||
#include"ast_pp.h"
|
||||
#include"arith_decl_plugin.h"
|
||||
#include"simplifier.h"
|
||||
#include"basic_simplifier_plugin.h"
|
||||
#include"arith_simplifier_plugin.h"
|
||||
#include"front_end_params.h"
|
||||
#include"grobner.h"
|
||||
#include"reg_decl_plugins.h"
|
||||
|
||||
void display_eqs(grobner & gb, v_dependency_manager & dep_m) {
|
||||
std::cerr << "RESULT:\n";
|
||||
ptr_vector<grobner::equation> eqs;
|
||||
gb.get_equations(eqs);
|
||||
ptr_vector<grobner::equation>::iterator it = eqs.begin();
|
||||
ptr_vector<grobner::equation>::iterator end = eqs.end();
|
||||
for (; it != end; ++it) {
|
||||
grobner::equation * eq = *it;
|
||||
ptr_vector<void> exs;
|
||||
v_dependency * d = eq->get_dependency();
|
||||
dep_m.linearize(d, exs);
|
||||
std::cerr << "{";
|
||||
ptr_vector<void>::iterator it2 = exs.begin();
|
||||
ptr_vector<void>::iterator end2 = exs.end();
|
||||
for (bool first = true; it2 != end2; ++it2) {
|
||||
if (first) first = false; else std::cerr << " ";
|
||||
std::cerr << *it2;
|
||||
}
|
||||
std::cerr << "}, lc: " << eq->is_linear_combination() << ", ";
|
||||
gb.display_equation(std::cerr, *eq);
|
||||
}
|
||||
}
|
||||
|
||||
void tst_grobner(char ** argv, int argc, int & i) {
|
||||
front_end_params params;
|
||||
if (i + 1 < argc) {
|
||||
char const* file_path = argv[i+1];
|
||||
|
||||
ast_manager m;
|
||||
smtlib::parser* parser = smtlib::parser::create(m);
|
||||
reg_decl_plugins(m);
|
||||
parser->initialize_smtlib();
|
||||
|
||||
if (!parser->parse_file(file_path)) {
|
||||
std::cout << "Could not parse file : " << file_path << std::endl;
|
||||
dealloc(parser);
|
||||
return;
|
||||
}
|
||||
|
||||
smtlib::benchmark* b = parser->get_benchmark();
|
||||
simplifier simp(m);
|
||||
basic_simplifier_plugin * bp = alloc(basic_simplifier_plugin, m);
|
||||
simp.register_plugin(bp);
|
||||
simp.register_plugin(alloc(arith_simplifier_plugin, m, *bp, params));
|
||||
arith_util util(m);
|
||||
v_dependency_manager dep_m;
|
||||
grobner gb(m, dep_m);
|
||||
|
||||
ptr_vector<expr>::const_iterator it = b->begin_axioms();
|
||||
ptr_vector<expr>::const_iterator end = b->end_axioms();
|
||||
for (unsigned idx = 1; it != end; ++it, ++idx) {
|
||||
expr * ax = *it;
|
||||
expr_ref s_ax(m);
|
||||
proof_ref pr(m);
|
||||
simp(ax, s_ax, pr);
|
||||
std::cerr << mk_pp(s_ax, m) << "\n";
|
||||
if (m.is_eq(s_ax))
|
||||
gb.assert_eq(s_ax, dep_m.mk_leaf(reinterpret_cast<void*>(idx)));
|
||||
}
|
||||
gb.display(std::cerr);
|
||||
gb.compute_basis(1024);
|
||||
display_eqs(gb, dep_m);
|
||||
dealloc(parser);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -123,7 +123,6 @@ int main(int argc, char ** argv) {
|
|||
memory::initialize(0);
|
||||
bool do_display_usage = false;
|
||||
parse_cmd_line_args(argc, argv, do_display_usage);
|
||||
TST_ARGV(grobner);
|
||||
TST(random);
|
||||
TST(vector);
|
||||
TST(symbol_table);
|
||||
|
|
@ -131,23 +130,17 @@ int main(int argc, char ** argv) {
|
|||
TST(symbol);
|
||||
TST(heap);
|
||||
TST(hashtable);
|
||||
TST_ARGV(smtparser);
|
||||
TST(rational);
|
||||
TST(inf_rational);
|
||||
TST(ast);
|
||||
TST(optional);
|
||||
TST(bit_vector);
|
||||
TST(ast_pp);
|
||||
TST(ast_smt_pp);
|
||||
TST_ARGV(expr_delta);
|
||||
TST(string_buffer);
|
||||
TST(map);
|
||||
TST(diff_logic);
|
||||
TST(uint_set);
|
||||
TST_ARGV(expr_rand);
|
||||
TST(expr_context_simplifier);
|
||||
TST(ini_file);
|
||||
TST(expr_pattern_match);
|
||||
TST(list);
|
||||
TST(small_object_allocator);
|
||||
TST(timeout);
|
||||
|
|
@ -157,9 +150,6 @@ int main(int argc, char ** argv) {
|
|||
TST(bit_blaster);
|
||||
TST(var_subst);
|
||||
TST(simple_parser);
|
||||
TST(symmetry);
|
||||
TST_ARGV(symmetry_parse);
|
||||
TST_ARGV(symmetry_prove);
|
||||
TST(api);
|
||||
TST(old_interval);
|
||||
TST(interval_skip_list);
|
||||
|
|
@ -167,10 +157,8 @@ int main(int argc, char ** argv) {
|
|||
TST(memory);
|
||||
TST(get_implied_equalities);
|
||||
TST(arith_simplifier_plugin);
|
||||
TST(quant_elim);
|
||||
TST(matcher);
|
||||
TST(datalog_parser);
|
||||
TST(dl_rule_set);
|
||||
TST_ARGV(datalog_parser_file);
|
||||
TST(object_allocator);
|
||||
TST(mpz);
|
||||
|
|
@ -208,7 +196,6 @@ int main(int argc, char ** argv) {
|
|||
TST(prime_generator);
|
||||
TST(permutation);
|
||||
TST(nlsat);
|
||||
TST(qe_defs);
|
||||
TST(ext_numeral);
|
||||
TST(interval);
|
||||
TST(quant_solve);
|
||||
|
|
|
|||
|
|
@ -1,52 +0,0 @@
|
|||
#ifdef _WINDOWS
|
||||
#include <iostream>
|
||||
#include <strstream>
|
||||
#include <fstream>
|
||||
#include <sstream>
|
||||
#include "smtparser.h"
|
||||
#include "for_each_file.h"
|
||||
#include "array_decl_plugin.h"
|
||||
#include "bv_decl_plugin.h"
|
||||
#include "reg_decl_plugins.h"
|
||||
|
||||
class for_each_file_smt : public for_each_file_proc {
|
||||
public:
|
||||
for_each_file_smt() {}
|
||||
|
||||
bool operator()(char const * file_path) {
|
||||
bool result = true;
|
||||
std::cout << "Parsing: " << file_path << std::endl;
|
||||
|
||||
ast_manager ast_manager;
|
||||
smtlib::parser* parser = smtlib::parser::create(ast_manager);
|
||||
reg_decl_plugins(ast_manager);
|
||||
|
||||
parser->initialize_smtlib();
|
||||
|
||||
if (!parser->parse_file(file_path)) {
|
||||
std::cout << "Could not parse file : " << file_path << std::endl;
|
||||
result = false;
|
||||
}
|
||||
dealloc(parser);
|
||||
return result;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
static bool test_directory(char const * base) {
|
||||
for_each_file_smt foreach;
|
||||
return for_each_file(foreach, base, "*.smt");
|
||||
}
|
||||
|
||||
void tst_smtparser(char** argv, int argc, int & i) {
|
||||
bool result = true;
|
||||
if (i + 1 < argc) {
|
||||
result = test_directory(argv[i+1]);
|
||||
i += 1;
|
||||
}
|
||||
SASSERT(result);
|
||||
}
|
||||
#else
|
||||
void tst_smtparser(char** argv, int argc, int & i) {
|
||||
}
|
||||
#endif
|
||||
|
|
@ -17,7 +17,6 @@ Revision History:
|
|||
|
||||
--*/
|
||||
#include"var_subst.h"
|
||||
#include"smtparser.h"
|
||||
#include"ast_pp.h"
|
||||
#include"arith_decl_plugin.h"
|
||||
#include"bv_decl_plugin.h"
|
||||
|
|
@ -104,22 +103,4 @@ void tst_var_subst() {
|
|||
ast_manager m;
|
||||
reg_decl_plugins(m);
|
||||
tst_subst(m);
|
||||
|
||||
scoped_ptr<smtlib::parser> parser = smtlib::parser::create(m);
|
||||
parser->initialize_smtlib();
|
||||
|
||||
parser->parse_string(
|
||||
"(benchmark samples :logic AUFLIA\n"
|
||||
" :extrafuns ((f Int Int) (g Int Int Int) (a Int) (b Int))\n"
|
||||
" :formula (forall (x Int) (or (= (f x) x) (forall (y Int) (z Int) (= (g x y) (f z)))))\n"
|
||||
" :formula (forall (x Int) (w Int) (or (= (f x) x) (forall (y Int) (z Int) (or (= (g x y) (g w z)) (forall (x1 Int) (= (f x1) (g x y)))))))\n"
|
||||
")"
|
||||
);
|
||||
|
||||
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)
|
||||
tst_instantiate(m, *it);
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue