mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-08-18 09:12:16 +00:00
Code Activity

Merge branch 'unstable' of https://git01.codeplex.com/z3 into unstable

Browse source
This commit is contained in:
Nikolaj Bjorner 2012-11-18 18:31:59 -08:00
commit 9c304d7642
11 changed files with 407 additions and 382 deletions
Download patch file Download diff file Expand all files Collapse all files

2
RELEASE_NOTES
View file

@ -5,6 +5,8 @@ Version 4.3.2
- Added get_version() and get_version_string() to Z3Py
- Added support for FreeBSD. Z3 can be compiled on FreeBSD using g++.
Version 4.3.1
=============

42
configure.ac
View file

@ -101,15 +101,15 @@ AC_PROG_SED
AS_IF([test "$CXX" = "g++"], [
# Enable OpenMP
CXXFLAGS+=" -fopenmp"
LDFLAGS+=" -fopenmp"
SLIBEXTRAFLAGS+=" -fopenmp"
CXXFLAGS="$CXXFLAGS -fopenmp"
LDFLAGS="$LDFLAGS -fopenmp"
SLIBEXTRAFLAGS="$SLIBEXTRAFLAGS -fopenmp"
# Use -mfpmath=sse
CXXFLAGS+=" -mfpmath=sse"
CXXFLAGS="$CXXFLAGS -mfpmath=sse"
],
[test "$CXX" = "clang++"], [
# OpenMP is not supported in clang++
CXXFLAGS+=" -D _NO_OMP_"
CXXFLAGS="$CXXFLAGS -D _NO_OMP_"
],
[
AC_MSG_ERROR([Unsupported compiler: $CXX])
@ -128,28 +128,38 @@ host_os=`uname -s`
AS_IF([test "$host_os" = "Darwin"], [
PLATFORM=osx
SO_EXT=.dylib
SLIBFLAGS+="-dynamiclib"
SLIBFLAGS="$SLIBFLAGS -dynamiclib"
COMP_VERSIONS="-compatibility_version \$(Z3_VERSION) -current_version \$(Z3_VERSION)"
STATIC_FLAGS=
], [test "$host_os" = "Linux"], [
CXXFLAGS=$CXXFLAGS -D _LINUX_
PLATFORM=linux
SO_EXT=.so
LDFLAGS+=" -lrt"
SLIBFLAGS+=" -shared"
LDFLAGS="$LDFLAGS -lrt"
SLIBFLAGS="$SLIBFLAGS -shared"
COMP_VERSIONS=
STATIC_FLAGS=-static
CXXFLAGS+=" -fno-strict-aliasing"
CXXFLAGS="$CXXFLAGS -fno-strict-aliasing"
if test "$CXX" = "clang++"; then
# More flags for clang++ for Linux
CXXFLAGS+=" -Wno-unknown-pragmas -Wno-overloaded-virtual -Wno-unused-value"
CXXFLAGS="$CXXFLAGS -Wno-unknown-pragmas -Wno-overloaded-virtual -Wno-unused-value"
fi
SLIBEXTRAFLAGS+=" -lrt"
SLIBEXTRAFLAGS="$SLIBEXTRAFLAGS -lrt"
], [test "$host_os" = "FreeBSD"], [
CXXFLAGS="$CXXFLAGS -D _FREEBSD_"
PLATFORM=bsd
SO_EXT=.so
LDFLAGS="$LDFLAGS -lrt"
SLIBFLAGS="$SLIBFLAGS -shared"
COMP_VERSIONS=
STATIC_FLAGS=-static
SLIBEXTRAFLAGS="$SLIBEXTRAFLAGS -lrt"
], [test "${host_os:0:6}" = "CYGWIN"], [
PLATFORM=win
SO_EXT=.dll
SLIBFLAGS+="-shared"
SLIBFLAGS="$SLIBFLAGS -shared"
COMP_VERSIONS=
CXXFLAGS+=" -D_CYGWIN -fno-strict-aliasing"
CXXFLAGS="$CXXFLAGS -D_CYGWIN -fno-strict-aliasing"
],
[
AC_MSG_ERROR([Unknown host platform: $host_os])
@ -169,11 +179,11 @@ AC_CHECK_SIZEOF(int *)
if test $ac_cv_sizeof_int_p -eq 8; then
dnl In 64-bit systems we have to compile using -fPIC
CXXFLAGS+=" -fPIC"
CPPFLAGS+=" -D_AMD64_"
CXXFLAGS="$CXXFLAGS -fPIC"
CPPFLAGS="$CPPFLAGS -D_AMD64_"
dnl Only enable use of thread local storage for 64-bit Linux. It is disabled for OSX and 32-bit Linux
if test $PLATFORM = "linux"; then
CPPFLAGS+=" -D_USE_THREAD_LOCAL"
CPPFLAGS="$CPPFLAGS -D_USE_THREAD_LOCAL"
fi
IS_X64="yes"
else

4
scripts/mk_project.py
View file

@ -30,7 +30,7 @@ def init_project_def():
# Simplifier module will be deleted in the future.
# It has been replaced with rewriter module.
add_lib('simplifier', ['rewriter', 'front_end_params'], 'ast/simplifier')
add_lib('normal_forms', ['rewriter', 'simplifier'], 'ast/normal_forms')
add_lib('normal_forms', ['rewriter', 'front_end_params'], 'ast/normal_forms')
add_lib('core_tactics', ['tactic', 'normal_forms'], 'tactic/core')
add_lib('sat_tactic', ['tactic', 'sat'], 'sat/tactic')
add_lib('arith_tactics', ['core_tactics', 'sat'], 'tactic/arith')
@ -41,7 +41,7 @@ def init_project_def():
add_lib('cmd_context', ['solver', 'rewriter'])
add_lib('extra_cmds', ['cmd_context', 'subpaving_tactic', 'arith_tactics'], 'cmd_context/extra_cmds')
add_lib('smt2parser', ['cmd_context', 'parser_util'], 'parsers/smt2')
add_lib('pattern', ['normal_forms', 'smt2parser'], 'ast/pattern')
add_lib('pattern', ['normal_forms', 'smt2parser', 'simplifier'], 'ast/pattern')
add_lib('macros', ['simplifier', 'front_end_params'], 'ast/macros')
add_lib('proof_checker', ['rewriter', 'front_end_params'], 'ast/proof_checker')
add_lib('bit_blaster', ['rewriter', 'simplifier', 'front_end_params'], 'ast/rewriter/bit_blaster')

3
src/ast/normal_forms/cnf.cpp
View file

@ -16,8 +16,9 @@ Author:
Revision History:
--*/
#include"cnf.h"
#include"var_subst.h"
#include"ast_util.h"
#include"ast_pp.h"
#include"ast_ll_pp.h"

309
src/ast/normal_forms/pull_quant.cpp
View file

@ -17,10 +17,22 @@ Notes:
--*/
#include"pull_quant.h"
#include"var_subst.h"
#include"rewriter_def.h"
#include"ast_pp.h"
#include"for_each_expr.h"
void pull_quant::pull_quant1(func_decl * d, unsigned num_children, expr * const * children, expr_ref & result) {
struct pull_quant::imp {
struct rw_cfg : public default_rewriter_cfg {
ast_manager & m_manager;
shift_vars m_shift;
rw_cfg(ast_manager & m):
m_manager(m),
m_shift(m) {
}
bool pull_quant1_core(func_decl * d, unsigned num_children, expr * const * children, expr_ref & result) {
ptr_buffer<sort> var_sorts;
buffer<symbol> var_names;
symbol qid;
@ -38,11 +50,11 @@ void pull_quant::pull_quant1(func_decl * d, unsigned num_children, expr * const
quantifier * q = to_quantifier(child);
expr * body = q->get_expr();
result = m_manager.update_quantifier(q, !q->is_forall(), m_manager.mk_not(body));
return true;
}
else {
result = m_manager.mk_not(child);
return false;
}
return;
}
bool found_quantifier = false;
@ -144,17 +156,25 @@ void pull_quant::pull_quant1(func_decl * d, unsigned num_children, expr * const
m_manager.mk_app(d, new_adjusted_children.size(), new_adjusted_children.c_ptr()),
w,
qid);
return true;
}
else {
SASSERT(!found_quantifier);
return false;
}
}
void pull_quant1(func_decl * d, unsigned num_children, expr * const * children, expr_ref & result) {
if (!pull_quant1_core(d, num_children, children, result)) {
result = m_manager.mk_app(d, num_children, children);
}
}
}
void pull_quant::pull_quant1(quantifier * q, expr * new_expr, expr_ref & result) {
void pull_quant1_core(quantifier * q, expr * new_expr, expr_ref & result) {
// The original formula was in SNF, so the original quantifiers must be universal.
SASSERT(is_forall(q));
if (is_forall(new_expr)) {
SASSERT(is_forall(new_expr));
quantifier * nested_q = to_quantifier(new_expr);
ptr_buffer<sort> var_sorts;
buffer<symbol> var_names;
@ -171,23 +191,30 @@ void pull_quant::pull_quant1(quantifier * q, expr * new_expr, expr_ref & result)
std::min(q->get_weight(), nested_q->get_weight()),
q->get_qid());
}
void pull_quant1(quantifier * q, expr * new_expr, expr_ref & result) {
// The original formula was in SNF, so the original quantifiers must be universal.
SASSERT(is_forall(q));
if (is_forall(new_expr)) {
pull_quant1_core(q, new_expr, result);
}
else {
SASSERT(!is_quantifier(new_expr));
result = m_manager.update_quantifier(q, new_expr);
}
}
}
void pull_quant::pull_quant1(expr * n, expr_ref & result) {
void pull_quant1(expr * n, expr_ref & result) {
if (is_app(n))
pull_quant1(to_app(n)->get_decl(), to_app(n)->get_num_args(), to_app(n)->get_args(), result);
else if (is_quantifier(n))
pull_quant1(to_quantifier(n), to_quantifier(n)->get_expr(), result);
else
result = n;
}
}
// Code for proof generation...
void pull_quant::pull_quant2(expr * n, expr_ref & r, proof_ref & pr) {
// Code for proof generation...
void pull_quant2(expr * n, expr_ref & r, proof_ref & pr) {
pr = 0;
if (is_app(n)) {
expr_ref_buffer new_args(m_manager);
@ -227,159 +254,135 @@ void pull_quant::pull_quant2(expr * n, expr_ref & r, proof_ref & pr) {
else {
r = n;
}
}
}
bool pull_quant::visit_children(expr * n) {
bool visited = true;
unsigned j;
switch(n->get_kind()) {
case AST_APP:
// This transformation is also applied after the formula
// has been converted into a SNF using only OR and NOT.
if (m_manager.is_or(n) || m_manager.is_and(n) || m_manager.is_not(n)) {
j = to_app(n)->get_num_args();
while (j > 0) {
--j;
visit(to_app(n)->get_arg(j), visited);
}
}
else {
// This class assumes the formula is in skolem normal form.
SASSERT(!has_quantifiers(n));
}
break;
case AST_QUANTIFIER:
if (to_quantifier(n)->is_forall())
visit(to_quantifier(n)->get_expr(), visited);
break;
default:
break;
}
return visited;
}
br_status reduce_app(func_decl * f, unsigned num, expr * const * args, expr_ref & result, proof_ref & result_pr) {
if (!m_manager.is_or(f) && !m_manager.is_and(f) && !m_manager.is_not(f))
return BR_FAILED;
void pull_quant::reduce1(expr * n) {
switch(n->get_kind()) {
case AST_APP:
reduce1_app(to_app(n));
break;
case AST_VAR:
cache_result(n, n, 0);
break;
case AST_QUANTIFIER:
reduce1_quantifier(to_quantifier(n));
break;
default:
if (!pull_quant1_core(f, num, args, result))
return BR_FAILED;
if (m_manager.proofs_enabled()) {
result_pr = m_manager.mk_pull_quant(m_manager.mk_app(f, num, args),
to_quantifier(result.get()));
}
return BR_DONE;
}
bool reduce_quantifier(quantifier * old_q,
expr * new_body,
expr * const * new_patterns,
expr * const * new_no_patterns,
expr_ref & result,
proof_ref & result_pr) {
if (old_q->is_exists()) {
UNREACHABLE();
break;
return false;
}
if (!is_forall(new_body))
return false;
pull_quant1_core(old_q, new_body, result);
if (m_manager.proofs_enabled())
result_pr = m_manager.mk_pull_quant(old_q, to_quantifier(result.get()));
return true;
}
};
struct rw : public rewriter_tpl<rw_cfg> {
rw_cfg m_cfg;
rw(ast_manager & m):
rewriter_tpl<rw_cfg>(m, m.proofs_enabled(), m_cfg),
m_cfg(m) {
}
};
rw m_rw;
imp(ast_manager & m):
m_rw(m) {
}
void operator()(expr * n, expr_ref & r, proof_ref & p) {
m_rw(n, r, p);
}
};
pull_quant::pull_quant(ast_manager & m) {
m_imp = alloc(imp, m);
}
void pull_quant::reduce1_app(app * n) {
if (m_manager.is_or(n) || m_manager.is_and(n) || m_manager.is_not(n)) {
ptr_buffer<expr> new_children;
ptr_buffer<proof> new_children_proofs;
unsigned num = n->get_num_args();
for (unsigned i = 0; i < num; i++) {
expr * new_child = 0;
proof * new_child_pr = 0;
get_cached(n->get_arg(i), new_child, new_child_pr);
new_children.push_back(new_child);
if (new_child_pr) {
new_children_proofs.push_back(new_child_pr);
}
}
expr_ref r(m_manager);
pull_quant1(n->get_decl(), new_children.size(), new_children.c_ptr(), r);
proof * pr = 0;
if (m_manager.fine_grain_proofs()) {
app * n_prime = m_manager.mk_app(n->get_decl(), new_children.size(), new_children.c_ptr());
TRACE("proof_bug", tout << mk_pp(n, m_manager) << "\n";
tout << mk_pp(n_prime, m_manager) << "\n";);
proof * p1 = n == n_prime ? 0 : m_manager.mk_congruence(n, n_prime,
new_children_proofs.size(), new_children_proofs.c_ptr());
proof * p2 = n_prime == r ? 0 : m_manager.mk_pull_quant(n_prime, to_quantifier(r));
pr = m_manager.mk_transitivity(p1, p2);
}
cache_result(n, r, pr);
return;
}
TRACE("proof_bug", tout << mk_pp(n, m_manager) << "\n";);
cache_result(n, n, 0);
}
void pull_quant::reduce1_quantifier(quantifier * q) {
if (q->is_forall()) {
expr * new_expr;
proof * new_expr_pr;
get_cached(q->get_expr(), new_expr, new_expr_pr);
expr_ref r(m_manager);
pull_quant1(q, new_expr, r);
proof * pr = 0;
if (m_manager.fine_grain_proofs()) {
quantifier * q_prime = m_manager.update_quantifier(q, new_expr);
proof * p1 = q == q_prime ? 0 : m_manager.mk_quant_intro(q, q_prime, new_expr_pr);
proof * p2 = q_prime == r ? 0 : m_manager.mk_pull_quant(q_prime, to_quantifier(r));
pr = m_manager.mk_transitivity(p1, p2);
}
cache_result(q, r, pr);
return;
}
// should be unreachable, right?
UNREACHABLE();
cache_result(q, q, 0);
}
pull_quant::pull_quant(ast_manager & m):
base_simplifier(m),
m_shift(m) {
pull_quant::~pull_quant() {
dealloc(m_imp);
}
void pull_quant::operator()(expr * n, expr_ref & r, proof_ref & p) {
flush_cache();
m_todo.push_back(n);
while (!m_todo.empty()) {
expr * n = m_todo.back();
if (is_cached(n))
m_todo.pop_back();
else if (visit_children(n)) {
m_todo.pop_back();
reduce1(n);
}
}
expr * result;
proof * result_proof;
get_cached(n, result, result_proof);
r = result;
switch (m_manager.proof_mode()) {
case PGM_DISABLED:
p = m_manager.mk_undef_proof();
break;
case PGM_COARSE:
if (result == n)
p = m_manager.mk_reflexivity(n);
else
p = m_manager.mk_pull_quant_star(n, to_quantifier(result));
break;
case PGM_FINE:
SASSERT(result_proof || result == n);
p = result_proof ? result_proof : m_manager.mk_reflexivity(n);
break;
}
(*m_imp)(n, r, p);
}
bool pull_nested_quant::visit_quantifier(quantifier * q) {
// do not recurse.
void pull_quant::reset() {
m_imp->m_rw.reset();
}
void pull_quant::pull_quant2(expr * n, expr_ref & r, proof_ref & pr) {
m_imp->m_rw.cfg().pull_quant2(n, r, pr);
}
struct pull_nested_quant::imp {
struct rw_cfg : public default_rewriter_cfg {
pull_quant m_pull;
expr_ref m_r;
proof_ref m_pr;
rw_cfg(ast_manager & m):m_pull(m), m_r(m), m_pr(m) {}
bool get_subst(expr * s, expr * & t, proof * & t_pr) {
if (!is_quantifier(s))
return false;
m_pull(to_quantifier(s), m_r, m_pr);
t = m_r.get();
t_pr = m_pr.get();
return true;
}
};
struct rw : public rewriter_tpl<rw_cfg> {
rw_cfg m_cfg;
rw(ast_manager & m):
rewriter_tpl<rw_cfg>(m, m.proofs_enabled(), m_cfg),
m_cfg(m) {
}
};
rw m_rw;
imp(ast_manager & m):
m_rw(m) {
}
void operator()(expr * n, expr_ref & r, proof_ref & p) {
m_rw(n, r, p);
}
};
pull_nested_quant::pull_nested_quant(ast_manager & m) {
m_imp = alloc(imp, m);
}
void pull_nested_quant::reduce1_quantifier(quantifier * q) {
expr_ref r(m_manager);
proof_ref pr(m_manager);
m_pull(q, r, pr);
cache_result(q, r, pr);
pull_nested_quant::~pull_nested_quant() {
dealloc(m_imp);
}
void pull_nested_quant::operator()(expr * n, expr_ref & r, proof_ref & p) {
(*m_imp)(n, r, p);
}
void pull_nested_quant::reset() {
m_imp->m_rw.reset();
}

34
src/ast/normal_forms/pull_quant.h
View file

@ -19,8 +19,7 @@ Notes:
#ifndef _PULL_QUANT_H_
#define _PULL_QUANT_H_
#include"simplifier.h"
#include"var_subst.h"
#include"ast.h"
/**
\brief Pull nested quantifiers in a formula.
@ -32,22 +31,14 @@ Notes:
\remark If pull_quant(F) is a quantifier then its weight is
Min{weight(Q') | Q' is a quantifier nested in F}
*/
class pull_quant : public base_simplifier {
protected:
shift_vars m_shift;
bool visit_children(expr * n);
void reduce1(expr *);
void reduce1_app(app * n);
void reduce1_quantifier(quantifier * q);
class pull_quant {
struct imp;
imp * m_imp;
public:
pull_quant(ast_manager & m);
virtual ~pull_quant() {}
~pull_quant();
void operator()(expr * n, expr_ref & r, proof_ref & p);
void reset() { flush_cache(); }
void pull_quant1(func_decl * d, unsigned num_children, expr * const * children, expr_ref & result);
void pull_quant1(quantifier * q, expr * new_expr, expr_ref & result);
void pull_quant1(expr * n, expr_ref & result);
void reset();
void pull_quant2(expr * n, expr_ref & r, proof_ref & pr);
};
@ -55,13 +46,14 @@ public:
\brief After applying this transformation the formula will not
contain nested quantifiers.
*/
class pull_nested_quant : public simplifier {
pull_quant m_pull;
virtual bool visit_quantifier(quantifier * q);
virtual void reduce1_quantifier(quantifier * q);
class pull_nested_quant {
struct imp;
imp * m_imp;
public:
pull_nested_quant(ast_manager & m):simplifier(m), m_pull(m) { enable_ac_support(false); }
virtual ~pull_nested_quant() {}
pull_nested_quant(ast_manager & m);
~pull_nested_quant();
void operator()(expr * n, expr_ref & r, proof_ref & p);
void reset();
};
#endif /* _PULL_QUANT_H_ */

0
src/ast/normal_forms/elim_term_ite.cpp → src/smt/elim_term_ite.cpp
View file

0
src/ast/normal_forms/elim_term_ite.h → src/smt/elim_term_ite.h
View file

39
src/util/scoped_timer.cpp
View file

@ -33,15 +33,22 @@ Revision History:
#include<sys/time.h>
#include<sys/errno.h>
#include<pthread.h>
#else
#elif defined(_LINUX_) || defined(_FREEBSD_)
// Linux
#include<csignal>
#include<ctime>
#include<memory.h>
#include"warning.h"
#define CLOCKID CLOCK_PROCESS_CPUTIME_ID
#ifdef _LINUX_
#define CLOCKID CLOCK_PROCESS_CPUTIME_ID
#else
// FreeBSD does not support CLOCK_PROCESS_CPUTIME_ID
#define CLOCKID CLOCK_PROF
#endif
#define SIG SIGRTMIN
// ---------
#else
// Other platforms
#endif
#include"scoped_timer.h"
@ -63,12 +70,14 @@ struct scoped_timer::imp {
pthread_attr_t m_attributes;
unsigned m_interval;
pthread_cond_t m_condition_var;
#else
// Linux
#elif defined(_LINUX_) || defined(_FREEBSD_)
// Linux & FreeBSD
static void * g_timer;
void (*m_old_handler)(int);
void * m_old_timer;
timer_t m_timerid;
#else
// Other
#endif
#if defined(_WINDOWS) || defined(_CYGWIN)
@ -117,10 +126,12 @@ struct scoped_timer::imp {
throw default_exception("failed to destroy pthread condition variable");
return st;
}
#else
#elif defined(_LINUX_) || defined(_FREEBSD_)
static void sig_handler(int) {
static_cast<imp*>(g_timer)->m_eh->operator()();
}
#else
// Other
#endif
@ -142,8 +153,8 @@ struct scoped_timer::imp {
throw default_exception("failed to initialize timer thread attributes");
if (pthread_create(&m_thread_id, &m_attributes, &thread_func, this) != 0)
throw default_exception("failed to start timer thread");
#else
// Linux version
#elif defined(_LINUX_) || defined(_FREEBSD_)
// Linux & FreeBSD
if (omp_in_parallel()) {
// It doesn't work in with more than one thread.
// SIGEV_SIGNAL: the event is handled by the process not by the thread that installed the handler.
@ -172,6 +183,8 @@ struct scoped_timer::imp {
its.it_interval.tv_nsec = 0;
if (timer_settime(m_timerid, 0, &its, NULL) == -1)
throw default_exception("failed to set timer");
#else
// Other platforms
#endif
}
@ -187,14 +200,16 @@ struct scoped_timer::imp {
throw default_exception("failed to join thread");
if (pthread_attr_destroy(&m_attributes) != 0)
throw default_exception("failed to destroy pthread attributes object");
#else
// Linux version
#elif defined(_LINUX_) || defined(_FREEBSD_)
// Linux & FreeBSD
if (omp_in_parallel())
return; // see comments in the constructor.
timer_delete(m_timerid);
if (m_old_handler != SIG_ERR)
signal(SIG, m_old_handler);
g_timer = m_old_timer;
#else
// Other Platforms
#endif
}
@ -203,9 +218,11 @@ struct scoped_timer::imp {
#if defined(_WINDOWS) || defined(_CYGWIN)
#elif defined(__APPLE__) && defined(__MACH__)
// Mac OS X
#else
// Linux
#elif defined(_LINUX_) || defined(_FREEBSD_)
// Linux & FreeBSD
void * scoped_timer::imp::g_timer = 0;
#else
// Other platforms
#endif
scoped_timer::scoped_timer(unsigned ms, event_handler * eh) {