mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-04-23 09:05:31 +00:00
Code Activity

merge with master branch

Browse source 
Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com>
This commit is contained in:
Nikolaj Bjorner 2017-09-19 09:39:22 -07:00
commit 651587ce01
1602 changed files with 40496 additions and 27837 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/muz/base/bind_variables.cpp
View file

@ -18,7 +18,7 @@ Notes:
--*/
#include "bind_variables.h"
#include "muz/base/bind_variables.h"
bind_variables::bind_variables(ast_manager & m):
m(m),

2
src/muz/base/bind_variables.h
View file

@ -21,7 +21,7 @@ Notes:
#ifndef BIND_VARIABLES_H_
#define BIND_VARIABLES_H_
#include"ast.h"
#include "ast/ast.h"
class bind_variables {
typedef obj_map<app, var*> var2bound;

10
src/muz/base/dl_boogie_proof.cpp
View file

@ -51,11 +51,11 @@ Example from Boogie:
")
*/
#include "dl_boogie_proof.h"
#include "model_pp.h"
#include "proof_utils.h"
#include "ast_pp.h"
#include "ast_util.h"
#include "muz/base/dl_boogie_proof.h"
#include "model/model_pp.h"
#include "muz/base/proof_utils.h"
#include "ast/ast_pp.h"
#include "ast/ast_util.h"
namespace datalog {

4
src/muz/base/dl_boogie_proof.h
View file

@ -48,8 +48,8 @@ define-fun) when Boogie supports this.
*/
#include "ast.h"
#include "model.h"
#include "ast/ast.h"
#include "model/model.h"
namespace datalog {
class boogie_proof {

97
src/muz/base/dl_context.cpp
View file

@ -19,16 +19,16 @@ Revision History:
#include<sstream>
#include<limits>
#include"arith_decl_plugin.h"
#include"bv_decl_plugin.h"
#include"dl_context.h"
#include"for_each_expr.h"
#include"ast_smt_pp.h"
#include"ast_smt2_pp.h"
#include"datatype_decl_plugin.h"
#include"scoped_proof.h"
#include"fixedpoint_params.hpp"
#include"ast_pp_util.h"
#include "ast/arith_decl_plugin.h"
#include "ast/bv_decl_plugin.h"
#include "muz/base/dl_context.h"
#include "ast/for_each_expr.h"
#include "ast/ast_smt_pp.h"
#include "ast/ast_smt2_pp.h"
#include "ast/datatype_decl_plugin.h"
#include "ast/scoped_proof.h"
#include "muz/base/fixedpoint_params.hpp"
#include "ast/ast_pp_util.h"
namespace datalog {
@ -229,6 +229,7 @@ namespace datalog {
m_enable_bind_variables(true),
m_last_status(OK),
m_last_answer(m),
m_last_ground_answer(m),
m_engine_type(LAST_ENGINE) {
re.set_context(this);
updt_params(pa);
@ -306,6 +307,8 @@ namespace datalog {
bool context::compress_unbound() const { return m_params->xform_compress_unbound(); }
bool context::quantify_arrays() const { return m_params->xform_quantify_arrays(); }
bool context::instantiate_quantifiers() const { return m_params->xform_instantiate_quantifiers(); }
bool context::array_blast() const { return m_params->xform_array_blast(); }
bool context::array_blast_full() const { return m_params->xform_array_blast_full(); }
void context::register_finite_sort(sort * s, sort_kind k) {
@ -546,10 +549,20 @@ namespace datalog {
return m_engine->get_cover_delta(level, pred);
}
expr_ref context::get_reachable(func_decl *pred) {
ensure_engine();
return m_engine->get_reachable(pred);
}
void context::add_cover(int level, func_decl* pred, expr* property) {
ensure_engine();
m_engine->add_cover(level, pred, property);
}
void context::add_invariant(func_decl* pred, expr *property)
{
ensure_engine();
m_engine->add_invariant(pred, property);
}
void context::check_rules(rule_set& r) {
m_rule_properties.set_generate_proof(generate_proof_trace());
@ -561,6 +574,7 @@ namespace datalog {
m_rule_properties.check_nested_free();
m_rule_properties.check_infinite_sorts();
break;
case SPACER_ENGINE:
case PDR_ENGINE:
m_rule_properties.collect(r);
m_rule_properties.check_existential_tail();
@ -792,6 +806,9 @@ namespace datalog {
if (e == symbol("datalog")) {
m_engine_type = DATALOG_ENGINE;
}
else if (e == symbol("spacer")) {
m_engine_type = SPACER_ENGINE;
}
else if (e == symbol("pdr")) {
m_engine_type = PDR_ENGINE;
}
@ -844,8 +861,10 @@ namespace datalog {
m_mc = mk_skip_model_converter();
m_last_status = OK;
m_last_answer = 0;
m_last_ground_answer = 0;
switch (get_engine()) {
case DATALOG_ENGINE:
case SPACER_ENGINE:
case PDR_ENGINE:
case QPDR_ENGINE:
case BMC_ENGINE:
@ -867,6 +886,28 @@ namespace datalog {
return m_engine->query(query);
}
lbool context::query_from_lvl (expr* query, unsigned lvl) {
m_mc = mk_skip_model_converter();
m_last_status = OK;
m_last_answer = 0;
m_last_ground_answer = 0;
switch (get_engine()) {
case DATALOG_ENGINE:
case SPACER_ENGINE:
case PDR_ENGINE:
case QPDR_ENGINE:
case BMC_ENGINE:
case QBMC_ENGINE:
case TAB_ENGINE:
case CLP_ENGINE:
flush_add_rules();
break;
default:
UNREACHABLE();
}
ensure_engine();
return m_engine->query_from_lvl (query, lvl);
}
model_ref context::get_model() {
ensure_engine();
return m_engine->get_model();
@ -905,6 +946,42 @@ namespace datalog {
return m_last_answer.get();
}
expr* context::get_ground_sat_answer () {
if (m_last_ground_answer) {
return m_last_ground_answer;
}
ensure_engine ();
m_last_ground_answer = m_engine->get_ground_sat_answer ();
return m_last_ground_answer;
}
void context::get_rules_along_trace (rule_ref_vector& rules) {
ensure_engine ();
m_engine->get_rules_along_trace (rules);
}
void context::get_rules_along_trace_as_formulas (expr_ref_vector& rules, svector<symbol>& names) {
rule_manager& rm = get_rule_manager ();
rule_ref_vector rv (rm);
get_rules_along_trace (rv);
expr_ref fml (m);
rule_ref_vector::iterator it = rv.begin (), end = rv.end ();
for (; it != end; it++) {
m_rule_manager.to_formula (**it, fml);
rules.push_back (fml);
// The concatenated names are already stored last-first, so do not need to be reversed here
const symbol& rule_name = (*it)->name();
names.push_back (rule_name);
TRACE ("dl",
if (rule_name == symbol::null) {
tout << "Encountered unnamed rule: ";
(*it)->display(*this, tout);
tout << "\n";
});
}
}
void context::display_certificate(std::ostream& out) {
ensure_engine();
m_engine->display_certificate(out);

65
src/muz/base/dl_context.h
View file

@ -23,26 +23,26 @@ Revision History:
#undef min
#undef max
#endif
#include"arith_decl_plugin.h"
#include"map.h"
#include"th_rewriter.h"
#include"str_hashtable.h"
#include"var_subst.h"
#include"dl_costs.h"
#include"dl_decl_plugin.h"
#include"dl_rule_set.h"
#include"lbool.h"
#include"statistics.h"
#include"params.h"
#include"trail.h"
#include"model_converter.h"
#include"model2expr.h"
#include"smt_params.h"
#include"dl_rule_transformer.h"
#include"expr_functors.h"
#include"dl_engine_base.h"
#include"bind_variables.h"
#include"rule_properties.h"
#include "ast/arith_decl_plugin.h"
#include "util/map.h"
#include "ast/rewriter/th_rewriter.h"
#include "util/str_hashtable.h"
#include "ast/rewriter/var_subst.h"
#include "muz/base/dl_costs.h"
#include "ast/dl_decl_plugin.h"
#include "muz/base/dl_rule_set.h"
#include "util/lbool.h"
#include "util/statistics.h"
#include "util/params.h"
#include "util/trail.h"
#include "tactic/model_converter.h"
#include "model/model2expr.h"
#include "smt/params/smt_params.h"
#include "muz/base/dl_rule_transformer.h"
#include "ast/expr_functors.h"
#include "muz/base/dl_engine_base.h"
#include "muz/base/bind_variables.h"
#include "muz/base/rule_properties.h"
struct fixedpoint_params;
@ -207,6 +207,7 @@ namespace datalog {
bool m_enable_bind_variables;
execution_result m_last_status;
expr_ref m_last_answer;
expr_ref m_last_ground_answer;
DL_ENGINE m_engine_type;
@ -277,6 +278,8 @@ namespace datalog {
bool xform_bit_blast() const;
bool xform_slice() const;
bool xform_coi() const;
bool array_blast() const;
bool array_blast_full() const;
void register_finite_sort(sort * s, sort_kind k);
@ -407,6 +410,10 @@ namespace datalog {
*/
unsigned get_num_levels(func_decl* pred);
/**
Retrieve reachable facts of 'pred'.
*/
expr_ref get_reachable(func_decl *pred);
/**
Retrieve the current cover of 'pred' up to 'level' unfoldings.
Return just the delta that is known at 'level'. To
@ -421,6 +428,11 @@ namespace datalog {
*/
void add_cover(int level, func_decl* pred, expr* property);
/**
Add an invariant of predicate 'pred'.
*/
void add_invariant (func_decl *pred, expr *property);
/**
\brief Check rule subsumption.
*/
@ -509,6 +521,7 @@ namespace datalog {
lbool query(expr* q);
lbool query_from_lvl (expr* q, unsigned lvl);
/**
\brief retrieve model from inductive invariant that shows query is unsat.
@ -545,6 +558,18 @@ namespace datalog {
in the query that are derivable.
*/
expr* get_answer_as_formula();
/**
* get bottom-up (from query) sequence of ground predicate instances
* (for e.g. P(0,1,0,0,3)) that together form a ground derivation to query
*/
expr* get_ground_sat_answer ();
/**
* \brief obtain the sequence of rules along the counterexample trace
*/
void get_rules_along_trace (rule_ref_vector& rules);
void get_rules_along_trace_as_formulas (expr_ref_vector& rules, svector<symbol>& names);
void collect_statistics(statistics& st) const;

10
src/muz/base/dl_costs.cpp
View file

@ -17,11 +17,11 @@ Revision History:
--*/
#include "debug.h"
#include "stopwatch.h"
#include "dl_context.h"
#include "dl_rule.h"
#include "dl_costs.h"
#include "util/debug.h"
#include "util/stopwatch.h"
#include "muz/base/dl_context.h"
#include "muz/base/dl_rule.h"
#include "muz/base/dl_costs.h"
namespace datalog {

2
src/muz/base/dl_costs.h
View file

@ -22,7 +22,7 @@ Revision History:
#include<iosfwd>
#include "ast.h"
#include "ast/ast.h"
class stopwatch;

19
src/muz/base/dl_engine_base.h
View file

@ -19,12 +19,14 @@ Revision History:
#ifndef DL_ENGINE_BASE_H_
#define DL_ENGINE_BASE_H_
#include "model.h"
#include "model/model.h"
#include "muz/base/dl_util.h"
namespace datalog {
enum DL_ENGINE {
DATALOG_ENGINE,
PDR_ENGINE,
SPACER_ENGINE,
QPDR_ENGINE,
BMC_ENGINE,
QBMC_ENGINE,
@ -43,6 +45,9 @@ namespace datalog {
virtual ~engine_base() {}
virtual expr_ref get_answer() = 0;
virtual expr_ref get_ground_sat_answer () {
throw default_exception(std::string("operation is not supported for ") + m_name);
}
virtual lbool query(expr* q) = 0;
virtual lbool query(unsigned num_rels, func_decl*const* rels) {
if (num_rels != 1) return l_undef;
@ -64,6 +69,9 @@ namespace datalog {
}
return query(q);
}
virtual lbool query_from_lvl (expr* q, unsigned lvl) {
throw default_exception(std::string("operation is not supported for ") + m_name);
}
virtual void reset_statistics() {}
virtual void display_profile(std::ostream& out) {}
@ -71,18 +79,27 @@ namespace datalog {
virtual unsigned get_num_levels(func_decl* pred) {
throw default_exception(std::string("get_num_levels is not supported for ") + m_name);
}
virtual expr_ref get_reachable(func_decl* pred) {
throw default_exception(std::string("operation is not supported for ") + m_name);
}
virtual expr_ref get_cover_delta(int level, func_decl* pred) {
throw default_exception(std::string("operation is not supported for ") + m_name);
}
virtual void add_cover(int level, func_decl* pred, expr* property) {
throw default_exception(std::string("operation is not supported for ") + m_name);
}
virtual void add_invariant (func_decl *pred, expr *property) {
throw default_exception(std::string("operation is not supported for ") + m_name);
}
virtual void display_certificate(std::ostream& out) const {
throw default_exception(std::string("certificates are not supported for ") + m_name);
}
virtual model_ref get_model() {
return model_ref(alloc(model, m));
}
virtual void get_rules_along_trace (rule_ref_vector& rules) {
throw default_exception(std::string("get_rules_along_trace is not supported for ") + m_name);
}
virtual proof_ref get_proof() {
return proof_ref(m.mk_asserted(m.mk_true()), m);
}

47
src/muz/base/dl_rule.cpp
View file

@ -24,26 +24,27 @@ Revision History:
#include<algorithm>
#include<sstream>
#include"ast_pp.h"
#include"dl_context.h"
#include"map.h"
#include"recurse_expr_def.h"
#include"dl_rule.h"
#include"qe.h"
#include"for_each_expr.h"
#include"used_vars.h"
#include"var_subst.h"
#include"rewriter_def.h"
#include"th_rewriter.h"
#include"ast_smt2_pp.h"
#include"used_symbols.h"
#include"quant_hoist.h"
#include"expr_replacer.h"
#include"bool_rewriter.h"
#include"expr_safe_replace.h"
#include"filter_model_converter.h"
#include"scoped_proof.h"
#include"datatype_decl_plugin.h"
#include "ast/ast_pp.h"
#include "muz/base/dl_context.h"
#include "util/map.h"
#include "ast/recurse_expr_def.h"
#include "muz/base/dl_rule.h"
#include "qe/qe.h"
#include "ast/for_each_expr.h"
#include "ast/used_vars.h"
#include "ast/rewriter/var_subst.h"
#include "ast/rewriter/rewriter_def.h"
#include "ast/rewriter/th_rewriter.h"
#include "ast/ast_smt2_pp.h"
#include "ast/used_symbols.h"
#include "ast/rewriter/quant_hoist.h"
#include "ast/rewriter/expr_replacer.h"
#include "ast/rewriter/bool_rewriter.h"
#include "ast/rewriter/expr_safe_replace.h"
#include "tactic/filter_model_converter.h"
#include "ast/scoped_proof.h"
#include "ast/datatype_decl_plugin.h"
#include "ast/ast_util.h"
namespace datalog {
@ -54,7 +55,7 @@ namespace datalog {
m_head(m),
m_args(m),
m_hnf(m),
m_qe(m, params_ref()),
m_qe(m, params_ref(), false),
m_rwr(m),
m_ufproc(m) {}
@ -639,7 +640,7 @@ namespace datalog {
tail.push_back(ensure_app(conjs[i].get()));
}
tail_neg.resize(tail.size(), false);
r = mk(r->get_head(), tail.size(), tail.c_ptr(), tail_neg.c_ptr());
r = mk(r->get_head(), tail.size(), tail.c_ptr(), tail_neg.c_ptr(), r->name());
TRACE("dl", r->display(m_ctx, tout << "reduced rule\n"););
}
}
@ -757,7 +758,7 @@ namespace datalog {
);
proof_ref pr(m);
qe::expr_quant_elim_star1 simpl(m, m_ctx.get_fparams());
qe::simplify_rewriter_star simpl(m);
simpl(quant_tail, fixed_tail, pr);
}
else {

26
src/muz/base/dl_rule.h
View file

@ -20,19 +20,19 @@ Revision History:
#ifndef DL_RULE_H_
#define DL_RULE_H_
#include"ast.h"
#include"dl_costs.h"
#include"dl_util.h"
#include"used_vars.h"
#include"proof_converter.h"
#include"model_converter.h"
#include"ast_counter.h"
#include"rewriter.h"
#include"hnf.h"
#include"qe_lite.h"
#include"var_subst.h"
#include"datatype_decl_plugin.h"
#include"label_rewriter.h"
#include "ast/ast.h"
#include "muz/base/dl_costs.h"
#include "muz/base/dl_util.h"
#include "ast/used_vars.h"
#include "tactic/proof_converter.h"
#include "tactic/model_converter.h"
#include "ast/rewriter/ast_counter.h"
#include "ast/rewriter/rewriter.h"
#include "muz/base/hnf.h"
#include "qe/qe_lite.h"
#include "ast/rewriter/var_subst.h"
#include "ast/datatype_decl_plugin.h"
#include "ast/rewriter/label_rewriter.h"
namespace datalog {

6
src/muz/base/dl_rule_set.cpp
View file

@ -19,9 +19,9 @@ Revision History:
#include<algorithm>
#include<functional>
#include"dl_context.h"
#include"dl_rule_set.h"
#include"ast_pp.h"
#include "muz/base/dl_context.h"
#include "muz/base/dl_rule_set.h"
#include "ast/ast_pp.h"
namespace datalog {

4
src/muz/base/dl_rule_set.h
View file

@ -19,8 +19,8 @@ Revision History:
#ifndef DL_RULE_SET_H_
#define DL_RULE_SET_H_
#include"obj_hashtable.h"
#include"dl_rule.h"
#include "util/obj_hashtable.h"
#include "muz/base/dl_rule.h"
namespace datalog {

4
src/muz/base/dl_rule_subsumption_index.cpp
View file

@ -20,9 +20,9 @@ Revision History:
#include <sstream>
#include "ast_pp.h"
#include "ast/ast_pp.h"
#include "dl_rule_subsumption_index.h"
#include "muz/base/dl_rule_subsumption_index.h"
namespace datalog {

2
src/muz/base/dl_rule_subsumption_index.h
View file

@ -21,7 +21,7 @@ Revision History:
#ifndef DL_RULE_SUBSUMPTION_INDEX_H_
#define DL_RULE_SUBSUMPTION_INDEX_H_
#include "dl_context.h"
#include "muz/base/dl_context.h"
namespace datalog {

6
src/muz/base/dl_rule_transformer.cpp
View file

@ -20,9 +20,9 @@ Revision History:
#include <algorithm>
#include<typeinfo>
#include"dl_context.h"
#include"dl_rule_transformer.h"
#include"stopwatch.h"
#include "muz/base/dl_context.h"
#include "muz/base/dl_rule_transformer.h"
#include "util/stopwatch.h"
namespace datalog {

8
src/muz/base/dl_rule_transformer.h
View file

@ -19,10 +19,10 @@ Revision History:
#ifndef DL_RULE_TRANSFORMER_H_
#define DL_RULE_TRANSFORMER_H_
#include"map.h"
#include"vector.h"
#include"dl_rule.h"
#include"dl_rule_set.h"
#include "util/map.h"
#include "util/vector.h"
#include "muz/base/dl_rule.h"
#include "muz/base/dl_rule_set.h"
namespace datalog {

16
src/muz/base/dl_util.cpp
View file

@ -23,14 +23,14 @@ Revision History:
#ifdef _WINDOWS
#include <windows.h>
#endif
#include"ast_pp.h"
#include"bool_rewriter.h"
#include"for_each_expr.h"
#include"scoped_proof.h"
#include"dl_context.h"
#include"dl_rule.h"
#include"dl_util.h"
#include"stopwatch.h"
#include "ast/ast_pp.h"
#include "ast/rewriter/bool_rewriter.h"
#include "ast/for_each_expr.h"
#include "ast/scoped_proof.h"
#include "muz/base/dl_context.h"
#include "muz/base/dl_rule.h"
#include "muz/base/dl_util.h"
#include "util/stopwatch.h"
namespace datalog {

23
src/muz/base/dl_util.h
View file

@ -20,17 +20,17 @@ Revision History:
#define DL_UTIL_H_
#include<vector>
#include"ast.h"
#include"hashtable.h"
#include"obj_hashtable.h"
#include"uint_set.h"
#include"horn_subsume_model_converter.h"
#include"replace_proof_converter.h"
#include"substitution.h"
#include"ast_counter.h"
#include"statistics.h"
#include"stopwatch.h"
#include"lbool.h"
#include "ast/ast.h"
#include "util/hashtable.h"
#include "util/obj_hashtable.h"
#include "util/uint_set.h"
#include "tactic/horn_subsume_model_converter.h"
#include "tactic/replace_proof_converter.h"
#include "ast/substitution/substitution.h"
#include "ast/rewriter/ast_counter.h"
#include "util/statistics.h"
#include "util/stopwatch.h"
#include "util/lbool.h"
namespace datalog {
@ -52,6 +52,7 @@ namespace datalog {
~verbose_action();
};
typedef ref_vector<rule, rule_manager> rule_ref_vector;
enum PDR_CACHE_MODE {
NO_CACHE,
HASH_CACHE,

58
src/muz/base/fixedpoint_params.pyg
View file

@ -3,7 +3,7 @@ def_module_params('fixedpoint',
export=True,
params=(('timeout', UINT, UINT_MAX, 'set timeout'),
('engine', SYMBOL, 'auto-config',
'Select: auto-config, datalog, duality, pdr, bmc'),
'Select: auto-config, datalog, duality, pdr, bmc, spacer'),
('datalog.default_table', SYMBOL, 'sparse',
'default table implementation: sparse, hashtable, bitvector, interval'),
('datalog.default_relation', SYMBOL, 'pentagon',
@ -54,6 +54,8 @@ def_module_params('fixedpoint',
"if true, finite_product_relation will attempt to avoid creating " +
"inner relation with empty signature by putting in half of the " +
"table columns, if it would have been empty otherwise"),
('datalog.subsumption', BOOL, True,
"if true, removes/filters predicates with total transitions"),
('duality.full_expand', BOOL, False, 'Fully expand derivation trees'),
('duality.no_conj', BOOL, False, 'No forced covering (conjectures)'),
('duality.feasible_edges', BOOL, True,
@ -74,6 +76,8 @@ def_module_params('fixedpoint',
('pdr.flexible_trace', BOOL, False,
"allow PDR generate long counter-examples " +
"by extending candidate trace within search area"),
('pdr.flexible_trace_depth', UINT, UINT_MAX,
'Controls the depth (below the current level) at which flexible trace can be applied'),
('pdr.use_model_generalizer', BOOL, False,
"use model for backwards propagation (instead of symbolic simulation)"),
('pdr.validate_result', BOOL, False,
@ -138,13 +142,65 @@ def_module_params('fixedpoint',
('xform.slice', BOOL, True, "simplify clause set using slicing"),
('xform.karr', BOOL, False,
"Add linear invariants to clauses using Karr's method"),
('spacer.use_eqclass', BOOL, False, "Generalizes equalities to equivalence classes"),
('xform.transform_arrays', BOOL, False,
"Rewrites arrays equalities and applies select over store"),
('xform.instantiate_arrays', BOOL, False,
"Transforms P(a) into P(i, a[i] a)"),
('xform.instantiate_arrays.enforce', BOOL, False,
"Transforms P(a) into P(i, a[i]), discards a from predicate"),
('xform.instantiate_arrays.nb_quantifier', UINT, 1,
"Gives the number of quantifiers per array"),
('xform.instantiate_arrays.slice_technique', SYMBOL, "no-slicing",
"<no-slicing>=> GetId(i) = i, <smash> => GetId(i) = true"),
('xform.quantify_arrays', BOOL, False,
"create quantified Horn clauses from clauses with arrays"),
('xform.instantiate_quantifiers', BOOL, False,
"instantiate quantified Horn clauses using E-matching heuristic"),
('xform.coalesce_rules', BOOL, False, "coalesce rules"),
('xform.tail_simplifier_pve', BOOL, True, "propagate_variable_equivalences"),
('xform.subsumption_checker', BOOL, True, "Enable subsumption checker (no support for model conversion)"),
('xform.coi', BOOL, True, "use cone of influence simplificaiton"),
('duality.enable_restarts', BOOL, False, 'DUALITY: enable restarts'),
('spacer.order_children', UINT, 0, 'SPACER: order of enqueuing children in non-linear rules : 0 (original), 1 (reverse)'),
('spacer.eager_reach_check', BOOL, True, 'SPACER: eagerly check if a query is reachable using reachability facts of predecessors'),
('spacer.use_lemma_as_cti', BOOL, False, 'SPACER: use a lemma instead of a CTI in flexible_trace'),
('spacer.reset_obligation_queue', BOOL, True, 'SPACER: reset obligation queue when entering a new level'),
('spacer.init_reach_facts', BOOL, True, 'SPACER: initialize reachability facts with false'),
('spacer.use_array_eq_generalizer', BOOL, True, 'SPACER: attempt to generalize lemmas with array equalities'),
('spacer.use_derivations', BOOL, True, 'SPACER: using derivation mechanism to cache intermediate results for non-linear rules'),
('xform.array_blast', BOOL, False, "try to eliminate local array terms using Ackermannization -- some array terms may remain"),
('xform.array_blast_full', BOOL, False, "eliminate all local array variables by QE"),
('spacer.skip_propagate', BOOL, False, "Skip propagate/pushing phase. Turns PDR into a BMC that returns either reachable or unknown"),
('spacer.max_level', UINT, UINT_MAX, "Maximum level to explore"),
('spacer.elim_aux', BOOL, True, "Eliminate auxiliary variables in reachability facts"),
('spacer.reach_as_init', BOOL, True, "Extend initial rules with computed reachability facts"),
('spacer.blast_term_ite', BOOL, True, "Expand non-Boolean ite-terms"),
('spacer.nondet_tie_break', BOOL, False, "Break ties in obligation queue non-deterministicly"),
('spacer.reach_dnf', BOOL, True, "Restrict reachability facts to DNF"),
('bmc.linear_unrolling_depth', UINT, UINT_MAX, "Maximal level to explore"),
('spacer.split_farkas_literals', BOOL, False, "Split Farkas literals"),
('spacer.native_mbp', BOOL, False, "Use native mbp of Z3"),
('spacer.eq_prop', BOOL, True, "Enable equality and bound propagation in arithmetic"),
('spacer.weak_abs', BOOL, True, "Weak abstraction"),
('spacer.restarts', BOOL, False, "Enable reseting obligation queue"),
('spacer.restart_initial_threshold', UINT, 10, "Intial threshold for restarts"),
('spacer.random_seed', UINT, 0, "Random seed to be used by SMT solver"),
('spacer.ground_cti', BOOL, True, "Require CTI to be ground"),
('spacer.vs.dump_benchmarks', BOOL, False, 'dump benchmarks in virtual solver'),
('spacer.vs.dump_min_time', DOUBLE, 5.0, 'min time to dump benchmark'),
('spacer.vs.recheck', BOOL, False, 're-check locally during benchmark dumping'),
('spacer.mbqi', BOOL, True, 'use model-based quantifier instantiation'),
('spacer.keep_proxy', BOOL, True, 'keep proxy variables (internal parameter)'),
('spacer.instantiate', BOOL, True, 'instantiate quantified lemmas'),
('spacer.qlemmas', BOOL, True, 'allow quantified lemmas in frames'),
('spacer.new_unsat_core', BOOL, True, 'use the new implementation of unsat-core-generation'),
('spacer.minimize_unsat_core', BOOL, False, 'compute unsat-core by min-cut'),
('spacer.farkas_optimized', BOOL, True, 'use the optimized farkas plugin, which performs gaussian elimination'),
('spacer.farkas_a_const', BOOL, True, 'if the unoptimized farkas plugin is used, use the constants from A while constructing unsat_cores'),
('spacer.lemma_sanity_check', BOOL, False, 'check during generalization whether lemma is actually correct'),
('spacer.reuse_pobs', BOOL, True, 'reuse POBs'),
('spacer.simplify_pob', BOOL, False, 'simplify POBs by removing redundant constraints')
))

28
src/muz/base/hnf.cpp
View file

@ -43,20 +43,20 @@ Notes:
--*/
#include"hnf.h"
#include"warning.h"
#include"used_vars.h"
#include"well_sorted.h"
#include"var_subst.h"
#include"name_exprs.h"
#include"act_cache.h"
#include"cooperate.h"
#include"ast_pp.h"
#include"quant_hoist.h"
#include"ast_util.h"
#include"dl_util.h"
#include"for_each_ast.h"
#include"for_each_expr.h"
#include "muz/base/hnf.h"
#include "util/warning.h"
#include "ast/used_vars.h"
#include "ast/well_sorted.h"
#include "ast/rewriter/var_subst.h"
#include "ast/normal_forms/name_exprs.h"
#include "ast/act_cache.h"
#include "util/cooperate.h"
#include "ast/ast_pp.h"
#include "ast/rewriter/quant_hoist.h"
#include "ast/ast_util.h"
#include "muz/base/dl_util.h"
#include "ast/for_each_ast.h"
#include "ast/for_each_expr.h"
class hnf::imp {

8
src/muz/base/hnf.h
View file

@ -25,10 +25,10 @@ Copyright (c) 2015 Microsoft Corporation
#ifndef HNF_H_
#define HNF_H_
#include"ast.h"
#include"params.h"
#include"defined_names.h"
#include"proof_converter.h"
#include "ast/ast.h"
#include "util/params.h"
#include "ast/normal_forms/defined_names.h"
#include "tactic/proof_converter.h"
class hnf {
class imp;

60
src/muz/base/proof_utils.cpp
View file

@ -4,20 +4,27 @@ Copyright (c) 2015 Microsoft Corporation
--*/
#include "dl_util.h"
#include "proof_utils.h"
#include "ast_smt2_pp.h"
#include "var_subst.h"
#include "muz/base/dl_util.h"
#include "muz/base/proof_utils.h"
#include "ast/ast_smt2_pp.h"
#include "ast/rewriter/var_subst.h"
class reduce_hypotheses {
typedef obj_hashtable<expr> expr_set;
ast_manager& m;
// reference for any expression created by the tranformation
expr_ref_vector m_refs;
// currently computed result
obj_map<proof,proof*> m_cache;
// map conclusions to closed proofs that derive them
obj_map<expr, proof*> m_units;
// currently active units
ptr_vector<expr> m_units_trail;
// size of m_units_trail at the last push
unsigned_vector m_limits;
// map from proofs to active hypotheses
obj_map<proof, expr_set*> m_hypmap;
// refernce train for hypotheses sets
ptr_vector<expr_set> m_hyprefs;
ptr_vector<expr> m_literals;
@ -151,19 +158,33 @@ public:
p = result;
return;
}
//SASSERT (p.get () == result);
switch(p->get_decl_kind()) {
case PR_HYPOTHESIS:
// replace result by m_units[m.get_fact (p)] if defined
// AG: This is the main step. Replace a hypothesis by a derivation of its consequence
if (!m_units.find(m.get_fact(p), result)) {
// restore ther result back to p
result = p.get();
}
// compute hypothesis of the result
// not clear what 'result' is at this point.
// probably the proof at the top of the call
// XXX not clear why this is re-computed each time
// XXX moreover, m_units are guaranteed to be closed!
// XXX so no hypotheses are needed for them
add_hypotheses(result);
break;
case PR_LEMMA: {
SASSERT(m.get_num_parents(p) == 1);
tmp = m.get_parent(p, 0);
// eliminate hypothesis recursively in the proof of the lemma
elim(tmp);
expr_set* hyps = m_hypmap.find(tmp);
expr_set* new_hyps = 0;
// XXX if the proof is correct, the hypotheses of the tmp
// XXX should be exactly those of the consequence of the lemma
// XXX but if this code actually eliminates hypotheses, the set might be a subset
if (hyps) {
new_hyps = alloc(expr_set, *hyps);
}
@ -178,13 +199,19 @@ public:
get_literals(fact);
}
// go over all the literals in the consequence of the lemma
for (unsigned i = 0; i < m_literals.size(); ++i) {
expr* e = m_literals[i];
// if the literal is not in hypothesis, skip it
if (!in_hypotheses(e, hyps)) {
m_literals[i] = m_literals.back();
m_literals.pop_back();
--i;
}
// if the literal is in hypothesis remove it because
// it is not in hypothesis set of the lemma
// XXX but we assume that lemmas have empty hypothesis set.
// XXX eventually every element of new_hyps must be removed!
else {
SASSERT(new_hyps);
expr_ref not_e = complement_lit(e);
@ -192,10 +219,13 @@ public:
new_hyps->remove(not_e);
}
}
// killed all hypotheses, so can stop at the lemma since
// we have a closed pf of false
if (m_literals.empty()) {
result = tmp;
}
else {
// create a new lemma, but might be re-creating existing one
expr_ref clause(m);
if (m_literals.size() == 1) {
clause = m_literals[0];
@ -212,6 +242,7 @@ public:
new_hyps = 0;
}
m_hypmap.insert(result, new_hyps);
// might push 0 into m_hyprefs. No reason for that
m_hyprefs.push_back(new_hyps);
TRACE("proof_utils",
tout << "New lemma: " << mk_pp(m.get_fact(p), m)
@ -229,19 +260,27 @@ public:
}
case PR_UNIT_RESOLUTION: {
proof_ref_vector parents(m);
// get the clause being resolved with
parents.push_back(m.get_parent(p, 0));
// save state
push();
bool found_false = false;
// for every derivation of a unit literal
for (unsigned i = 1; i < m.get_num_parents(p); ++i) {
// see if it derives false
tmp = m.get_parent(p, i);
elim(tmp);
if (m.is_false(m.get_fact(tmp))) {
// if derived false, the whole pf is false and we can bail out
result = tmp;
found_false = true;
break;
}
// -- otherwise, the fact has not changed. nothing to simplify
SASSERT(m.get_fact(tmp) == m.get_fact(m.get_parent(p, i)));
parents.push_back(tmp);
// remember that we have this derivation while we have not poped the trail
// but only if the proof is closed (i.e., a real unit)
if (is_closed(tmp) && !m_units.contains(m.get_fact(tmp))) {
m_units.insert(m.get_fact(tmp), tmp);
m_units_trail.push_back(m.get_fact(tmp));
@ -251,10 +290,15 @@ public:
pop();
break;
}
// look at the clause being resolved with
tmp = m.get_parent(p, 0);
// remember its fact
expr* old_clause = m.get_fact(tmp);
// attempt to reduce its fact
elim(tmp);
// update parents
parents[0] = tmp;
// if the new fact is false, bail out
expr* clause = m.get_fact(tmp);
if (m.is_false(clause)) {
m_refs.push_back(tmp);
@ -264,8 +308,10 @@ public:
}
//
// case where clause is a literal in the old clause.
// i.e., reduce multi-literal clause to a unit
//
if (is_literal_in_clause(clause, old_clause)) {
// if the resulting literal was resolved, get a pf of false and bail out
bool found = false;
for (unsigned i = 1; !found && i < parents.size(); ++i) {
if (m.is_complement(clause, m.get_fact(parents[i].get()))) {
@ -277,6 +323,7 @@ public:
found = true;
}
}
// else if the resulting literal is not resolved, it is the new consequence
if (!found) {
result = parents[0].get();
}
@ -508,6 +555,11 @@ static void permute_unit_resolution(expr_ref_vector& refs, obj_map<proof,proof*>
SASSERT(params[0].is_symbol());
family_id tid = m.mk_family_id(params[0].get_symbol());
SASSERT(tid != null_family_id);
// AG: This can break a theory lemma. In particular, for Farkas lemmas the coefficients
// AG: for the literals propagated from the unit resolution are missing.
// AG: Why is this a good thing to do?
// AG: This can lead to merging of the units with other terms in interpolation,
// AG: but without farkas coefficients this does not make sense
prNew = m.mk_th_lemma(tid, m.get_fact(pr),
premises.size(), premises.c_ptr(), num_params-1, params+1);
}

10
src/muz/base/rule_properties.cpp
View file

@ -18,11 +18,11 @@ Notes:
--*/
#include"expr_functors.h"
#include"rule_properties.h"
#include"dl_rule_set.h"
#include"for_each_expr.h"
#include"dl_context.h"
#include "ast/expr_functors.h"
#include "muz/base/rule_properties.h"
#include "muz/base/dl_rule_set.h"
#include "ast/for_each_expr.h"
#include "muz/base/dl_context.h"
using namespace datalog;
rule_properties::rule_properties(ast_manager & m, rule_manager& rm, context& ctx, i_expr_pred& p):

8
src/muz/base/rule_properties.h
View file

@ -21,10 +21,10 @@ Notes:
#ifndef RULE_PROPERTIES_H_
#define RULE_PROPERTIES_H_
#include"ast.h"
#include"datatype_decl_plugin.h"
#include"bv_decl_plugin.h"
#include"dl_rule.h"
#include "ast/ast.h"
#include "ast/datatype_decl_plugin.h"
#include "ast/bv_decl_plugin.h"
#include "muz/base/dl_rule.h"
namespace datalog {
class rule_properties {

61
src/muz/bmc/dl_bmc_engine.cpp
View file

@ -17,21 +17,23 @@ Revision History:
--*/
#include "dl_context.h"
#include "dl_rule_transformer.h"
#include "dl_bmc_engine.h"
#include "dl_mk_slice.h"
#include "smt_kernel.h"
#include "datatype_decl_plugin.h"
#include "dl_decl_plugin.h"
#include "bool_rewriter.h"
#include "model_smt2_pp.h"
#include "ast_smt_pp.h"
#include "well_sorted.h"
#include "rewriter_def.h"
#include "dl_transforms.h"
#include "dl_mk_rule_inliner.h"
#include "scoped_proof.h"
#include "muz/base/dl_context.h"
#include "muz/base/dl_rule_transformer.h"
#include "muz/bmc/dl_bmc_engine.h"
#include "muz/transforms/dl_mk_slice.h"
#include "smt/smt_kernel.h"
#include "ast/datatype_decl_plugin.h"
#include "ast/dl_decl_plugin.h"
#include "ast/rewriter/bool_rewriter.h"
#include "model/model_smt2_pp.h"
#include "ast/ast_smt_pp.h"
#include "ast/well_sorted.h"
#include "ast/rewriter/rewriter_def.h"
#include "muz/transforms/dl_transforms.h"
#include "muz/transforms/dl_mk_rule_inliner.h"
#include "ast/scoped_proof.h"
#include "muz/base/fixedpoint_params.hpp"
namespace datalog {
@ -143,6 +145,7 @@ namespace datalog {
b.m_fparams.m_model = true;
b.m_fparams.m_model_compact = true;
b.m_fparams.m_mbqi = true;
b.m_rule_trace.reset();
}
void mk_qrule_vars(datalog::rule const& r, unsigned rule_id, expr_ref_vector& sub) {
@ -279,6 +282,7 @@ namespace datalog {
}
SASSERT(r);
mk_qrule_vars(*r, i, sub);
b.m_rule_trace.push_back(r);
// we have rule, we have variable names of rule.
// extract values for the variables in the rule.
@ -470,6 +474,7 @@ namespace datalog {
b.m_fparams.m_model_compact = true;
// b.m_fparams.m_mbqi = true;
b.m_fparams.m_relevancy_lvl = 2;
b.m_rule_trace.reset();
}
lbool check(unsigned level) {
@ -507,6 +512,7 @@ namespace datalog {
}
}
SASSERT(r);
b.m_rule_trace.push_back(r);
rm.to_formula(*r, fml);
IF_VERBOSE(1, verbose_stream() << mk_pp(fml, m) << "\n";);
prs.push_back(r->get_proof());
@ -760,6 +766,7 @@ namespace datalog {
b.m_fparams.m_model_compact = true;
b.m_fparams.m_mbqi = false;
b.m_fparams.m_relevancy_lvl = 2;
b.m_rule_trace.reset();
}
func_decl_ref mk_predicate(func_decl* pred) {
@ -963,7 +970,7 @@ namespace datalog {
_name << pred->get_name() << "_" << q->get_name() << j;
symbol name(_name.str().c_str());
type_ref tr(idx);
accs.push_back(mk_accessor_decl(name, tr));
accs.push_back(mk_accessor_decl(m, name, tr));
}
std::stringstream _name;
_name << pred->get_name() << "_" << i;
@ -972,7 +979,7 @@ namespace datalog {
symbol is_name(_name.str().c_str());
cnstrs.push_back(mk_constructor_decl(name, is_name, accs.size(), accs.c_ptr()));
}
dts.push_back(mk_datatype_decl(pred->get_name(), cnstrs.size(), cnstrs.c_ptr()));
dts.push_back(mk_datatype_decl(dtu, pred->get_name(), 0, nullptr, cnstrs.size(), cnstrs.c_ptr()));
}
@ -1017,10 +1024,10 @@ namespace datalog {
_name2 << "get_succ#" << i;
ptr_vector<accessor_decl> accs;
type_ref tr(0);
accs.push_back(mk_accessor_decl(name, tr));
accs.push_back(mk_accessor_decl(m, name, tr));
cnstrs.push_back(mk_constructor_decl(name, is_name, accs.size(), accs.c_ptr()));
}
dts.push_back(mk_datatype_decl(symbol("Path"), cnstrs.size(), cnstrs.c_ptr()));
dts.push_back(mk_datatype_decl(dtu, symbol("Path"), 0, nullptr, cnstrs.size(), cnstrs.c_ptr()));
VERIFY (dtp->mk_datatypes(dts.size(), dts.c_ptr(), 0, 0, new_sorts));
m_path_sort = new_sorts[0].get();
}
@ -1078,6 +1085,7 @@ namespace datalog {
}
head = rl->get_head();
pr = m.mk_hyper_resolve(sz+1, prs.c_ptr(), head, positions, substs);
b.m_rule_trace.push_back(rl.get());
return pr;
}
}
@ -1131,7 +1139,7 @@ namespace datalog {
md->eval(path, path);
IF_VERBOSE(2, verbose_stream() << mk_pp(trace, m) << "\n";
for (unsigned i = 0; i < b.m_solver.size(); ++i) {
verbose_stream() << mk_pp(b.m_solver.get_formulas()[i], m) << "\n";
verbose_stream() << mk_pp(b.m_solver.get_formula(i), m) << "\n";
});
scoped_proof _sp(m);
proof_ref pr(m);
@ -1154,7 +1162,8 @@ namespace datalog {
lbool check() {
setup();
for (unsigned i = 0; ; ++i) {
unsigned max_depth = b.m_ctx.get_params().bmc_linear_unrolling_depth();
for (unsigned i = 0; i < max_depth; ++i) {
IF_VERBOSE(1, verbose_stream() << "level: " << i << "\n";);
b.checkpoint();
compile(i);
@ -1167,6 +1176,7 @@ namespace datalog {
return res;
}
}
return l_undef;
}
private:
@ -1202,6 +1212,7 @@ namespace datalog {
}
}
SASSERT(r);
b.m_rule_trace.push_back(r);
mk_rule_vars(*r, level, i, sub);
// we have rule, we have variable names of rule.
@ -1284,6 +1295,7 @@ namespace datalog {
b.m_fparams.m_model_compact = true;
b.m_fparams.m_mbqi = false;
// m_fparams.m_auto_config = false;
b.m_rule_trace.reset();
}
@ -1426,7 +1438,8 @@ namespace datalog {
m_solver(m, m_fparams),
m_rules(ctx),
m_query_pred(m),
m_answer(m) {
m_answer(m),
m_rule_trace(ctx.get_rule_manager()) {
}
bmc::~bmc() {}
@ -1530,6 +1543,10 @@ namespace datalog {
return m_answer;
}
void bmc::get_rules_along_trace(datalog::rule_ref_vector& rules) {
rules.append(m_rule_trace);
}
void bmc::compile(rule_set const& rules, expr_ref_vector& fmls, unsigned level) {
nonlinear nl(*this);
nl.compile(rules, fmls, level);

12
src/muz/bmc/dl_bmc_engine.h
View file

@ -20,11 +20,11 @@ Revision History:
#ifndef DL_BMC_ENGINE_H_
#define DL_BMC_ENGINE_H_
#include "params.h"
#include "statistics.h"
#include "smt_kernel.h"
#include "bv_decl_plugin.h"
#include "smt_params.h"
#include "util/params.h"
#include "util/statistics.h"
#include "smt/smt_kernel.h"
#include "ast/bv_decl_plugin.h"
#include "smt/params/smt_params.h"
namespace datalog {
@ -38,6 +38,7 @@ namespace datalog {
rule_set m_rules;
func_decl_ref m_query_pred;
expr_ref m_answer;
rule_ref_vector m_rule_trace;
void checkpoint();
@ -63,6 +64,7 @@ namespace datalog {
void collect_statistics(statistics& st) const;
void reset_statistics();
void get_rules_along_trace(datalog::rule_ref_vector& rules);
expr_ref get_answer();

14
src/muz/clp/clp_context.cpp
View file

@ -17,13 +17,13 @@ Revision History:
--*/
#include "clp_context.h"
#include "dl_context.h"
#include "unifier.h"
#include "var_subst.h"
#include "substitution.h"
#include "smt_kernel.h"
#include "dl_transforms.h"
#include "muz/clp/clp_context.h"
#include "muz/base/dl_context.h"
#include "ast/substitution/unifier.h"
#include "ast/rewriter/var_subst.h"
#include "ast/substitution/substitution.h"
#include "smt/smt_kernel.h"
#include "muz/transforms/dl_transforms.h"
namespace datalog {

8
src/muz/clp/clp_context.h
View file

@ -19,10 +19,10 @@ Revision History:
#ifndef CLP_CONTEXT_H_
#define CLP_CONTEXT_H_
#include "ast.h"
#include "lbool.h"
#include "statistics.h"
#include "dl_engine_base.h"
#include "ast/ast.h"
#include "util/lbool.h"
#include "util/statistics.h"
#include "muz/base/dl_engine_base.h"
namespace datalog {
class context;

4
src/muz/dataflow/dataflow.cpp
View file

@ -15,8 +15,8 @@ Author:
--*/
#include "dataflow.h"
#include "reachability.h"
#include "muz/dataflow/dataflow.h"
#include "muz/dataflow/reachability.h"
namespace datalog {

8
src/muz/dataflow/dataflow.h
View file

@ -18,10 +18,10 @@ Author:
#ifndef DATAFLOW_H_
#define DATAFLOW_H_
#include "dl_rule.h"
#include "dl_rule_set.h"
#include "hashtable.h"
#include "vector.h"
#include "muz/base/dl_rule.h"
#include "muz/base/dl_rule_set.h"
#include "util/hashtable.h"
#include "util/vector.h"
namespace datalog {
template <typename Fact> class fact_reader;

2
src/muz/dataflow/reachability.h
View file

@ -17,7 +17,7 @@ Author:
#ifndef REACHABILITY_H_
#define REACHABILITY_H_
#include "dataflow.h"
#include "muz/dataflow/dataflow.h"
namespace datalog {
class reachability_info {

12
src/muz/ddnf/ddnf.cpp
View file

@ -20,12 +20,12 @@ Revision History:
--*/
#include "ddnf.h"
#include "dl_rule_set.h"
#include "dl_context.h"
#include "scoped_proof.h"
#include "bv_decl_plugin.h"
#include "tbv.h"
#include "muz/ddnf/ddnf.h"
#include "muz/base/dl_rule_set.h"
#include "muz/base/dl_context.h"
#include "ast/scoped_proof.h"
#include "ast/bv_decl_plugin.h"
#include "muz/rel/tbv.h"
namespace datalog {

8
src/muz/ddnf/ddnf.h
View file

@ -19,10 +19,10 @@ Revision History:
#ifndef DDNF_H_
#define DDNF_H_
#include "ast.h"
#include "lbool.h"
#include "statistics.h"
#include "dl_engine_base.h"
#include "ast/ast.h"
#include "util/lbool.h"
#include "util/statistics.h"
#include "muz/base/dl_engine_base.h"
class tbv;
class tbv_manager;

44
src/muz/duality/duality_dl_interface.cpp
View file

@ -18,26 +18,26 @@
--*/
#include "dl_context.h"
#include "dl_mk_coi_filter.h"
#include "dl_mk_interp_tail_simplifier.h"
#include "dl_mk_subsumption_checker.h"
#include "dl_mk_rule_inliner.h"
#include "dl_rule.h"
#include "dl_rule_transformer.h"
#include "smt2parser.h"
#include "duality_dl_interface.h"
#include "dl_rule_set.h"
#include "dl_mk_slice.h"
#include "dl_mk_unfold.h"
#include "dl_mk_coalesce.h"
#include "expr_abstract.h"
#include "model_smt2_pp.h"
#include "model_v2_pp.h"
#include "fixedpoint_params.hpp"
#include "used_vars.h"
#include "func_decl_dependencies.h"
#include "dl_transforms.h"
#include "muz/base/dl_context.h"
#include "muz/transforms/dl_mk_coi_filter.h"
#include "muz/transforms/dl_mk_interp_tail_simplifier.h"
#include "muz/transforms/dl_mk_subsumption_checker.h"
#include "muz/transforms/dl_mk_rule_inliner.h"
#include "muz/base/dl_rule.h"
#include "muz/base/dl_rule_transformer.h"
#include "parsers/smt2/smt2parser.h"
#include "muz/duality/duality_dl_interface.h"
#include "muz/base/dl_rule_set.h"
#include "muz/transforms/dl_mk_slice.h"
#include "muz/transforms/dl_mk_unfold.h"
#include "muz/transforms/dl_mk_coalesce.h"
#include "ast/expr_abstract.h"
#include "model/model_smt2_pp.h"
#include "model/model_v2_pp.h"
#include "muz/base/fixedpoint_params.hpp"
#include "ast/used_vars.h"
#include "ast/func_decl_dependencies.h"
#include "muz/transforms/dl_transforms.h"
// template class symbol_table<family_id>;
@ -48,8 +48,8 @@
#pragma warning(disable:4101)
#endif
#include "duality.h"
#include "duality_profiling.h"
#include "duality/duality.h"
#include "duality/duality_profiling.h"
// using namespace Duality;

10
src/muz/duality/duality_dl_interface.h
View file

@ -21,11 +21,11 @@
#ifndef DUALITY_DL_INTERFACE_H_
#define DUALITY_DL_INTERFACE_H_
#include "lbool.h"
#include "dl_rule.h"
#include "dl_rule_set.h"
#include "dl_engine_base.h"
#include "statistics.h"
#include "util/lbool.h"
#include "muz/base/dl_rule.h"
#include "muz/base/dl_rule_set.h"
#include "muz/base/dl_engine_base.h"
#include "util/statistics.h"
namespace datalog {
class context;

1
src/muz/fp/CMakeLists.txt
View file

@ -12,6 +12,7 @@ z3_add_component(fp
muz
pdr
rel
spacer
tab
TACTIC_HEADERS
horn_tactic.h

14
src/muz/fp/datalog_parser.cpp
View file

@ -5,13 +5,13 @@ Copyright (c) 2015 Microsoft Corporation
--*/
#include"datalog_parser.h"
#include"string_buffer.h"
#include"str_hashtable.h"
#include"ast_pp.h"
#include"arith_decl_plugin.h"
#include"region.h"
#include"warning.h"
#include "muz/fp/datalog_parser.h"
#include "util/string_buffer.h"
#include "util/str_hashtable.h"
#include "ast/ast_pp.h"
#include "ast/arith_decl_plugin.h"
#include "util/region.h"
#include "util/warning.h"
#include<iostream>
#include<sstream>
#include<cstdio>

4
src/muz/fp/datalog_parser.h
View file

@ -19,8 +19,8 @@ Revision History:
#ifndef DATALOG_PARSER_H_
#define DATALOG_PARSER_H_
#include "ast.h"
#include "dl_context.h"
#include "ast/ast.h"
#include "muz/base/dl_context.h"
namespace datalog {

32
src/muz/fp/dl_cmds.cpp
View file

@ -15,22 +15,22 @@ Author:
Notes:
--*/
#include"cmd_context.h"
#include"dl_cmds.h"
#include"dl_external_relation.h"
#include"dl_context.h"
#include"dl_register_engine.h"
#include"dl_decl_plugin.h"
#include"dl_instruction.h"
#include"dl_compiler.h"
#include"dl_rule.h"
#include"ast_pp.h"
#include"parametric_cmd.h"
#include"cancel_eh.h"
#include"scoped_ctrl_c.h"
#include"scoped_timer.h"
#include"trail.h"
#include"fixedpoint_params.hpp"
#include "cmd_context/cmd_context.h"
#include "muz/fp/dl_cmds.h"
#include "muz/rel/dl_external_relation.h"
#include "muz/base/dl_context.h"
#include "muz/fp/dl_register_engine.h"
#include "ast/dl_decl_plugin.h"
#include "muz/rel/dl_instruction.h"
#include "muz/rel/dl_compiler.h"
#include "muz/base/dl_rule.h"
#include "ast/ast_pp.h"
#include "cmd_context/parametric_cmd.h"
#include "util/cancel_eh.h"
#include "util/scoped_ctrl_c.h"
#include "util/scoped_timer.h"
#include "util/trail.h"
#include "muz/base/fixedpoint_params.hpp"
#include<iomanip>

2
src/muz/fp/dl_cmds.h
View file

@ -18,7 +18,7 @@ Notes:
#ifndef DL_CMDS_H_
#define DL_CMDS_H_
#include "ast.h"
#include "ast/ast.h"
class cmd_context;

19
src/muz/fp/dl_register_engine.cpp
View file

@ -16,14 +16,15 @@ Author:
Revision History:
--*/
#include "dl_register_engine.h"
#include "dl_bmc_engine.h"
#include "clp_context.h"
#include "tab_context.h"
#include "rel_context.h"
#include "pdr_dl_interface.h"
#include "ddnf.h"
#include "duality_dl_interface.h"
#include "muz/fp/dl_register_engine.h"
#include "muz/bmc/dl_bmc_engine.h"
#include "muz/clp/clp_context.h"
#include "muz/tab/tab_context.h"
#include "muz/rel/rel_context.h"
#include "muz/pdr/pdr_dl_interface.h"
#include "muz/ddnf/ddnf.h"
#include "muz/duality/duality_dl_interface.h"
#include "muz/spacer/spacer_dl_interface.h"
namespace datalog {
register_engine::register_engine(): m_ctx(0) {}
@ -33,6 +34,8 @@ namespace datalog {
case PDR_ENGINE:
case QPDR_ENGINE:
return alloc(pdr::dl_interface, *m_ctx);
case SPACER_ENGINE:
return alloc(spacer::dl_interface, *m_ctx);
case DATALOG_ENGINE:
return alloc(rel_context, *m_ctx);
case BMC_ENGINE:

2
src/muz/fp/dl_register_engine.h
View file

@ -19,7 +19,7 @@ Revision History:
#ifndef DL_REGISTER_ENGINE_H_
#define DL_REGISTER_ENGINE_H_
#include "dl_context.h"
#include "muz/base/dl_context.h"
namespace datalog {

28
src/muz/fp/horn_tactic.cpp
View file

@ -16,20 +16,20 @@ Author:
Revision History:
--*/
#include"tactical.h"
#include"model_converter.h"
#include"proof_converter.h"
#include"horn_tactic.h"
#include"dl_context.h"
#include"dl_register_engine.h"
#include"expr_replacer.h"
#include"dl_rule_transformer.h"
#include"dl_mk_slice.h"
#include"filter_model_converter.h"
#include"dl_transforms.h"
#include"fixedpoint_params.hpp"
#include"ast_util.h"
#include"var_subst.h"
#include "tactic/tactical.h"
#include "tactic/model_converter.h"
#include "tactic/proof_converter.h"
#include "muz/fp/horn_tactic.h"
#include "muz/base/dl_context.h"
#include "muz/fp/dl_register_engine.h"
#include "ast/rewriter/expr_replacer.h"
#include "muz/base/dl_rule_transformer.h"
#include "muz/transforms/dl_mk_slice.h"
#include "tactic/filter_model_converter.h"
#include "muz/transforms/dl_transforms.h"
#include "muz/base/fixedpoint_params.hpp"
#include "ast/ast_util.h"
#include "ast/rewriter/var_subst.h"
class horn_tactic : public tactic {
struct imp {

2
src/muz/fp/horn_tactic.h
View file

@ -19,7 +19,7 @@ Revision History:
#ifndef HORN_TACTIC_H_
#define HORN_TACTIC_H_
#include"params.h"
#include "util/params.h"
class ast_manager;
class tactic;

8
src/muz/pdr/pdr_closure.cpp
View file

@ -17,10 +17,10 @@ Revision History:
--*/
#include "pdr_closure.h"
#include "pdr_context.h"
#include "expr_safe_replace.h"
#include "ast_util.h"
#include "muz/pdr/pdr_closure.h"
#include "muz/pdr/pdr_context.h"
#include "ast/rewriter/expr_safe_replace.h"
#include "ast/ast_util.h"
namespace pdr {

2
src/muz/pdr/pdr_closure.h
View file

@ -20,7 +20,7 @@ Revision History:
#ifndef PDR_CLOSURE_H_
#define PDR_CLOSURE_H_
#include "arith_decl_plugin.h"
#include "ast/arith_decl_plugin.h"
namespace pdr {

56
src/muz/pdr/pdr_context.cpp
View file

@ -25,31 +25,31 @@ Notes:
#include <sstream>
#include "dl_util.h"
#include "rewriter.h"
#include "rewriter_def.h"
#include "var_subst.h"
#include "util.h"
#include "pdr_prop_solver.h"
#include "pdr_context.h"
#include "pdr_generalizers.h"
#include "for_each_expr.h"
#include "dl_rule_set.h"
#include "unit_subsumption_tactic.h"
#include "model_smt2_pp.h"
#include "dl_mk_rule_inliner.h"
#include "ast_smt2_pp.h"
#include "qe_lite.h"
#include "ast_ll_pp.h"
#include "proof_checker.h"
#include "smt_value_sort.h"
#include "proof_utils.h"
#include "dl_boogie_proof.h"
#include "scoped_proof.h"
#include "blast_term_ite_tactic.h"
#include "model_implicant.h"
#include "expr_safe_replace.h"
#include "ast_util.h"
#include "muz/base/dl_util.h"
#include "ast/rewriter/rewriter.h"
#include "ast/rewriter/rewriter_def.h"
#include "ast/rewriter/var_subst.h"
#include "util/util.h"
#include "muz/pdr/pdr_prop_solver.h"
#include "muz/pdr/pdr_context.h"
#include "muz/pdr/pdr_generalizers.h"
#include "ast/for_each_expr.h"
#include "muz/base/dl_rule_set.h"
#include "smt/tactic/unit_subsumption_tactic.h"
#include "model/model_smt2_pp.h"
#include "muz/transforms/dl_mk_rule_inliner.h"
#include "ast/ast_smt2_pp.h"
#include "qe/qe_lite.h"
#include "ast/ast_ll_pp.h"
#include "ast/proof_checker/proof_checker.h"
#include "smt/smt_value_sort.h"
#include "muz/base/proof_utils.h"
#include "muz/base/dl_boogie_proof.h"
#include "ast/scoped_proof.h"
#include "tactic/core/blast_term_ite_tactic.h"
#include "model/model_implicant.h"
#include "ast/rewriter/expr_safe_replace.h"
#include "ast/ast_util.h"
namespace pdr {
@ -1835,16 +1835,16 @@ namespace pdr {
!m_params.pdr_use_convex_interior_generalizer()) {
if (classify.is_dl()) {
m_fparams.m_arith_mode = AS_DIFF_LOGIC;
m_fparams.m_arith_expand_eqs = true;
m_fparams.m_arith_eq2ineq = true;
}
else if (classify.is_utvpi()) {
IF_VERBOSE(1, verbose_stream() << "UTVPI\n";);
m_fparams.m_arith_mode = AS_UTVPI;
m_fparams.m_arith_expand_eqs = true;
m_fparams.m_arith_eq2ineq = true;
}
else {
m_fparams.m_arith_mode = AS_ARITH;
m_fparams.m_arith_expand_eqs = false;
m_fparams.m_arith_eq2ineq = false;
}
}
}

8
src/muz/pdr/pdr_context.h
View file

@ -25,10 +25,10 @@ Revision History:
#undef max
#endif
#include <deque>
#include "pdr_manager.h"
#include "pdr_prop_solver.h"
#include "pdr_reachable_cache.h"
#include "fixedpoint_params.hpp"
#include "muz/pdr/pdr_manager.h"
#include "muz/pdr/pdr_prop_solver.h"
#include "muz/pdr/pdr_reachable_cache.h"
#include "muz/base/fixedpoint_params.hpp"
namespace datalog {

26
src/muz/pdr/pdr_dl_interface.cpp
View file

@ -17,19 +17,19 @@ Revision History:
--*/
#include "dl_context.h"
#include "dl_mk_coi_filter.h"
#include "dl_rule.h"
#include "dl_rule_transformer.h"
#include "pdr_context.h"
#include "pdr_dl_interface.h"
#include "dl_rule_set.h"
#include "dl_mk_slice.h"
#include "dl_mk_unfold.h"
#include "dl_mk_coalesce.h"
#include "dl_transforms.h"
#include "scoped_proof.h"
#include "model_smt2_pp.h"
#include "muz/base/dl_context.h"
#include "muz/transforms/dl_mk_coi_filter.h"
#include "muz/base/dl_rule.h"
#include "muz/base/dl_rule_transformer.h"
#include "muz/pdr/pdr_context.h"
#include "muz/pdr/pdr_dl_interface.h"
#include "muz/base/dl_rule_set.h"
#include "muz/transforms/dl_mk_slice.h"
#include "muz/transforms/dl_mk_unfold.h"
#include "muz/transforms/dl_mk_coalesce.h"
#include "muz/transforms/dl_transforms.h"
#include "ast/scoped_proof.h"
#include "model/model_smt2_pp.h"
using namespace pdr;

12
src/muz/pdr/pdr_dl_interface.h
View file

@ -20,12 +20,12 @@ Revision History:
#ifndef PDR_DL_INTERFACE_H_
#define PDR_DL_INTERFACE_H_
#include "lbool.h"
#include "dl_rule.h"
#include "dl_rule_set.h"
#include "dl_util.h"
#include "dl_engine_base.h"
#include "statistics.h"
#include "util/lbool.h"
#include "muz/base/dl_rule.h"
#include "muz/base/dl_rule_set.h"
#include "muz/base/dl_util.h"
#include "muz/base/dl_engine_base.h"
#include "util/statistics.h"
namespace datalog {
class context;

30
src/muz/pdr/pdr_farkas_learner.cpp
View file

@ -18,21 +18,21 @@ Revision History:
--*/
#include "ast_smt2_pp.h"
#include "array_decl_plugin.h"
#include "bool_rewriter.h"
#include "dl_decl_plugin.h"
#include "for_each_expr.h"
#include "dl_util.h"
#include "rewriter.h"
#include "rewriter_def.h"
#include "pdr_util.h"
#include "pdr_farkas_learner.h"
#include "th_rewriter.h"
#include "ast_ll_pp.h"
#include "arith_bounds_tactic.h"
#include "proof_utils.h"
#include "reg_decl_plugins.h"
#include "ast/ast_smt2_pp.h"
#include "ast/array_decl_plugin.h"
#include "ast/rewriter/bool_rewriter.h"
#include "ast/dl_decl_plugin.h"
#include "ast/for_each_expr.h"
#include "muz/base/dl_util.h"
#include "ast/rewriter/rewriter.h"
#include "ast/rewriter/rewriter_def.h"
#include "muz/pdr/pdr_util.h"
#include "muz/pdr/pdr_farkas_learner.h"
#include "ast/rewriter/th_rewriter.h"
#include "ast/ast_ll_pp.h"
#include "tactic/arith/arith_bounds_tactic.h"
#include "muz/base/proof_utils.h"
#include "ast/reg_decl_plugins.h"
namespace pdr {

16
src/muz/pdr/pdr_farkas_learner.h
View file

@ -20,14 +20,14 @@ Revision History:
#ifndef PDR_FARKAS_LEARNER_H_
#define PDR_FARKAS_LEARNER_H_
#include "arith_decl_plugin.h"
#include "ast_translation.h"
#include "bv_decl_plugin.h"
#include "smt_kernel.h"
#include "bool_rewriter.h"
#include "pdr_util.h"
#include "smt_params.h"
#include "tactic.h"
#include "ast/arith_decl_plugin.h"
#include "ast/ast_translation.h"
#include "ast/bv_decl_plugin.h"
#include "smt/smt_kernel.h"
#include "ast/rewriter/bool_rewriter.h"
#include "muz/pdr/pdr_util.h"
#include "smt/params/smt_params.h"
#include "tactic/tactic.h"
namespace pdr {

14
src/muz/pdr/pdr_generalizers.cpp
View file

@ -18,13 +18,13 @@ Revision History:
--*/
#include "pdr_context.h"
#include "pdr_farkas_learner.h"
#include "pdr_generalizers.h"
#include "expr_abstract.h"
#include "var_subst.h"
#include "expr_safe_replace.h"
#include "model_smt2_pp.h"
#include "muz/pdr/pdr_context.h"
#include "muz/pdr/pdr_farkas_learner.h"
#include "muz/pdr/pdr_generalizers.h"
#include "ast/expr_abstract.h"
#include "ast/rewriter/var_subst.h"
#include "ast/rewriter/expr_safe_replace.h"
#include "model/model_smt2_pp.h"
namespace pdr {

6
src/muz/pdr/pdr_generalizers.h
View file

@ -20,9 +20,9 @@ Revision History:
#ifndef PDR_GENERALIZERS_H_
#define PDR_GENERALIZERS_H_
#include "pdr_context.h"
#include "pdr_closure.h"
#include "arith_decl_plugin.h"
#include "muz/pdr/pdr_context.h"
#include "muz/pdr/pdr_closure.h"
#include "ast/arith_decl_plugin.h"
namespace pdr {

18
src/muz/pdr/pdr_manager.cpp
View file

@ -19,15 +19,15 @@ Revision History:
--*/
#include <sstream>
#include "pdr_manager.h"
#include "ast_smt2_pp.h"
#include "for_each_expr.h"
#include "has_free_vars.h"
#include "expr_replacer.h"
#include "expr_abstract.h"
#include "model2expr.h"
#include "model_smt2_pp.h"
#include "model_converter.h"
#include "muz/pdr/pdr_manager.h"
#include "ast/ast_smt2_pp.h"
#include "ast/for_each_expr.h"
#include "ast/has_free_vars.h"
#include "ast/rewriter/expr_replacer.h"
#include "ast/expr_abstract.h"
#include "model/model2expr.h"
#include "model/model_smt2_pp.h"
#include "tactic/model_converter.h"
namespace pdr {

22
src/muz/pdr/pdr_manager.h
View file

@ -23,17 +23,17 @@ Revision History:
#include <utility>
#include <map>
#include "bool_rewriter.h"
#include "expr_replacer.h"
#include "expr_substitution.h"
#include "map.h"
#include "ref_vector.h"
#include "smt_kernel.h"
#include "pdr_util.h"
#include "pdr_sym_mux.h"
#include "pdr_farkas_learner.h"
#include "pdr_smt_context_manager.h"
#include "dl_rule.h"
#include "ast/rewriter/bool_rewriter.h"
#include "ast/rewriter/expr_replacer.h"
#include "ast/expr_substitution.h"
#include "util/map.h"
#include "util/ref_vector.h"
#include "smt/smt_kernel.h"
#include "muz/pdr/pdr_util.h"
#include "muz/pdr/pdr_sym_mux.h"
#include "muz/pdr/pdr_farkas_learner.h"
#include "muz/pdr/pdr_smt_context_manager.h"
#include "muz/base/dl_rule.h"
namespace smt {

24
src/muz/pdr/pdr_prop_solver.cpp
View file

@ -18,18 +18,18 @@ Revision History:
--*/
#include <sstream>
#include "model.h"
#include "pdr_util.h"
#include "pdr_prop_solver.h"
#include "ast_smt2_pp.h"
#include "dl_util.h"
#include "model_pp.h"
#include "smt_params.h"
#include "datatype_decl_plugin.h"
#include "bv_decl_plugin.h"
#include "pdr_farkas_learner.h"
#include "ast_smt2_pp.h"
#include "expr_replacer.h"
#include "model/model.h"
#include "muz/pdr/pdr_util.h"
#include "muz/pdr/pdr_prop_solver.h"
#include "ast/ast_smt2_pp.h"
#include "muz/base/dl_util.h"
#include "model/model_pp.h"
#include "smt/params/smt_params.h"
#include "ast/datatype_decl_plugin.h"
#include "ast/bv_decl_plugin.h"
#include "muz/pdr/pdr_farkas_learner.h"
#include "ast/ast_smt2_pp.h"
#include "ast/rewriter/expr_replacer.h"
//
// Auxiliary structure to introduce propositional names for assumptions that are not

14
src/muz/pdr/pdr_prop_solver.h
View file

@ -23,13 +23,13 @@ Revision History:
#include <map>
#include <string>
#include <utility>
#include "ast.h"
#include "obj_hashtable.h"
#include "smt_kernel.h"
#include "util.h"
#include "vector.h"
#include "pdr_manager.h"
#include "pdr_smt_context_manager.h"
#include "ast/ast.h"
#include "util/obj_hashtable.h"
#include "smt/smt_kernel.h"
#include "util/util.h"
#include "util/vector.h"
#include "muz/pdr/pdr_manager.h"
#include "muz/pdr/pdr_smt_context_manager.h"
namespace pdr {

2
src/muz/pdr/pdr_reachable_cache.cpp
View file

@ -17,7 +17,7 @@ Revision History:
--*/
#include "pdr_reachable_cache.h"
#include "muz/pdr/pdr_reachable_cache.h"
namespace pdr {

8
src/muz/pdr/pdr_reachable_cache.h
View file

@ -20,10 +20,10 @@ Revision History:
#ifndef REACHABLE_CACHE_H_
#define REACHABLE_CACHE_H_
#include "ast.h"
#include "ref_vector.h"
#include "pdr_manager.h"
#include "pdr_smt_context_manager.h"
#include "ast/ast.h"
#include "util/ref_vector.h"
#include "muz/pdr/pdr_manager.h"
#include "muz/pdr/pdr_smt_context_manager.h"
namespace pdr {
class reachable_cache {

12
src/muz/pdr/pdr_smt_context_manager.cpp
View file

@ -17,12 +17,12 @@ Revision History:
--*/
#include "pdr_smt_context_manager.h"
#include "has_free_vars.h"
#include "ast_pp.h"
#include "ast_smt_pp.h"
#include "muz/pdr/pdr_smt_context_manager.h"
#include "ast/has_free_vars.h"
#include "ast/ast_pp.h"
#include "ast/ast_smt_pp.h"
#include <sstream>
#include "smt_params.h"
#include "smt/params/smt_params.h"
namespace pdr {
@ -83,7 +83,7 @@ namespace pdr {
{
ast_smt_pp pp(m);
for (unsigned i = 0; i < m_context.size(); ++i) {
pp.add_assumption(m_context.get_formulas()[i]);
pp.add_assumption(m_context.get_formula(i));
}
for (unsigned i = 0; i < assumptions.size(); ++i) {
pp.add_assumption(assumptions[i].get());

6
src/muz/pdr/pdr_smt_context_manager.h
View file

@ -20,9 +20,9 @@ Revision History:
#ifndef PDR_SMT_CONTEXT_MANAGER_H_
#define PDR_SMT_CONTEXT_MANAGER_H_
#include "smt_kernel.h"
#include "func_decl_dependencies.h"
#include "dl_util.h"
#include "smt/smt_kernel.h"
#include "ast/func_decl_dependencies.h"
#include "muz/base/dl_util.h"
namespace pdr {

14
src/muz/pdr/pdr_sym_mux.cpp
View file

@ -18,13 +18,13 @@ Revision History:
--*/
#include <sstream>
#include "ast_pp.h"
#include "for_each_expr.h"
#include "model.h"
#include "rewriter.h"
#include "rewriter_def.h"
#include "pdr_util.h"
#include "pdr_sym_mux.h"
#include "ast/ast_pp.h"
#include "ast/for_each_expr.h"
#include "model/model.h"
#include "ast/rewriter/rewriter.h"
#include "ast/rewriter/rewriter_def.h"
#include "muz/pdr/pdr_util.h"
#include "muz/pdr/pdr_sym_mux.h"
using namespace pdr;

6
src/muz/pdr/pdr_sym_mux.h
View file

@ -20,9 +20,9 @@ Revision History:
#ifndef SYM_MUX_H_
#define SYM_MUX_H_
#include "ast.h"
#include "map.h"
#include "vector.h"
#include "ast/ast.h"
#include "util/map.h"
#include "util/vector.h"
#include <vector>
class model_core;

43
src/muz/pdr/pdr_util.cpp
View file

@ -22,29 +22,26 @@ Notes:
--*/
#include <sstream>
#include "arith_simplifier_plugin.h"
#include "array_decl_plugin.h"
#include "ast_pp.h"
#include "basic_simplifier_plugin.h"
#include "bv_simplifier_plugin.h"
#include "bool_rewriter.h"
#include "dl_util.h"
#include "for_each_expr.h"
#include "smt_params.h"
#include "model.h"
#include "ref_vector.h"
#include "rewriter.h"
#include "rewriter_def.h"
#include "util.h"
#include "pdr_manager.h"
#include "pdr_util.h"
#include "arith_decl_plugin.h"
#include "expr_replacer.h"
#include "model_smt2_pp.h"
#include "poly_rewriter.h"
#include "poly_rewriter_def.h"
#include "arith_rewriter.h"
#include "scoped_proof.h"
#include "util/util.h"
#include "util/ref_vector.h"
#include "ast/array_decl_plugin.h"
#include "ast/ast_pp.h"
#include "ast/for_each_expr.h"
#include "ast/scoped_proof.h"
#include "ast/arith_decl_plugin.h"
#include "ast/rewriter/expr_replacer.h"
#include "ast/rewriter/bool_rewriter.h"
#include "ast/rewriter/poly_rewriter.h"
#include "ast/rewriter/poly_rewriter_def.h"
#include "ast/rewriter/arith_rewriter.h"
#include "ast/rewriter/rewriter.h"
#include "ast/rewriter/rewriter_def.h"
#include "smt/params/smt_params.h"
#include "model/model.h"
#include "muz/base/dl_util.h"
#include "muz/pdr/pdr_manager.h"
#include "muz/pdr/pdr_util.h"
#include "model/model_smt2_pp.h"

20
src/muz/pdr/pdr_util.h
View file

@ -20,16 +20,16 @@ Revision History:
#ifndef PDR_UTIL_H_
#define PDR_UTIL_H_
#include "ast.h"
#include "ast_pp.h"
#include "obj_hashtable.h"
#include "ref_vector.h"
#include "simplifier.h"
#include "trace.h"
#include "vector.h"
#include "arith_decl_plugin.h"
#include "array_decl_plugin.h"
#include "bv_decl_plugin.h"
#include "ast/ast.h"
#include "ast/ast_pp.h"
#include "ast/ast_util.h"
#include "util/obj_hashtable.h"
#include "util/ref_vector.h"
#include "util/trace.h"
#include "util/vector.h"
#include "ast/arith_decl_plugin.h"
#include "ast/array_decl_plugin.h"
#include "ast/bv_decl_plugin.h"
class model;

4
src/muz/rel/aig_exporter.cpp
View file

@ -11,8 +11,8 @@ Abstract:
--*/
#include "aig_exporter.h"
#include "dl_context.h"
#include "muz/rel/aig_exporter.h"
#include "muz/base/dl_context.h"
#include <set>
namespace datalog {

6
src/muz/rel/aig_exporter.h
View file

@ -14,11 +14,11 @@ Abstract:
#ifndef AIG_EXPORTER_H_
#define AIG_EXPORTER_H_
#include "aig.h"
#include "dl_rule_set.h"
#include "tactic/aig/aig.h"
#include "muz/base/dl_rule_set.h"
#include <map>
#include <sstream>
#include "rel_context.h"
#include "muz/rel/rel_context.h"
namespace datalog {
class aig_exporter {

8
src/muz/rel/check_relation.cpp
View file

@ -4,10 +4,10 @@ Copyright (c) 2015 Microsoft Corporation
--*/
#include "check_relation.h"
#include "dl_relation_manager.h"
#include "ast_util.h"
#include "smt_kernel.h"
#include "muz/rel/check_relation.h"
#include "muz/rel/dl_relation_manager.h"
#include "ast/ast_util.h"
#include "smt/smt_kernel.h"
#include <typeinfo>

4
src/muz/rel/check_relation.h
View file

@ -22,8 +22,8 @@ Revision History:
#ifndef CHECK_RELATION_H_
#define CHECK_RELATION_H_
#include "doc.h"
#include "dl_base.h"
#include "muz/rel/doc.h"
#include "muz/rel/dl_base.h"
namespace datalog {
class check_relation_plugin;

14
src/muz/rel/dl_base.cpp
View file

@ -18,13 +18,13 @@ Revision History:
--*/
#include"ast_pp.h"
#include"union_find.h"
#include"vector.h"
#include"dl_context.h"
#include"dl_base.h"
#include"bool_rewriter.h"
#include"dl_relation_manager.h"
#include "ast/ast_pp.h"
#include "util/union_find.h"
#include "util/vector.h"
#include "muz/base/dl_context.h"
#include "muz/rel/dl_base.h"
#include "ast/rewriter/bool_rewriter.h"
#include "muz/rel/dl_relation_manager.h"
#include<sstream>

12
src/muz/rel/dl_base.h
View file

@ -23,12 +23,12 @@ Revision History:
#include<iosfwd>
#include"ast.h"
#include"map.h"
#include"vector.h"
#include"ref.h"
#include"dl_util.h"
#include"dl_context.h"
#include "ast/ast.h"
#include "util/map.h"
#include "util/vector.h"
#include "util/ref.h"
#include "muz/base/dl_util.h"
#include "muz/base/dl_context.h"
namespace datalog {

8
src/muz/rel/dl_bound_relation.cpp
View file

@ -17,9 +17,9 @@ Revision History:
--*/
#include "dl_bound_relation.h"
#include "debug.h"
#include "ast_pp.h"
#include "muz/rel/dl_bound_relation.h"
#include "util/debug.h"
#include "ast/ast_pp.h"
namespace datalog {
@ -653,7 +653,7 @@ namespace datalog {
void bound_relation::to_formula(expr_ref& fml) const {
ast_manager& m = get_plugin().get_ast_manager();
arith_util& arith = get_plugin().m_arith;
basic_simplifier_plugin& bsimp = get_plugin().m_bsimp;
bool_rewriter& bsimp = get_plugin().m_bsimp;
expr_ref_vector conjs(m);
relation_signature const& sig = get_signature();
for (unsigned i = 0; i < sig.size(); ++i) {

18
src/muz/rel/dl_bound_relation.h
View file

@ -19,14 +19,14 @@ Revision History:
#ifndef DL_BOUND_RELATION_H_
#define DL_BOUND_RELATION_H_
#include "dl_context.h"
#include "dl_relation_manager.h"
#include "dl_base.h"
#include "uint_set.h"
#include "dl_vector_relation.h"
#include "dl_interval_relation.h"
#include "arith_decl_plugin.h"
#include "basic_simplifier_plugin.h"
#include "muz/base/dl_context.h"
#include "muz/rel/dl_relation_manager.h"
#include "muz/rel/dl_base.h"
#include "util/uint_set.h"
#include "muz/rel/dl_vector_relation.h"
#include "muz/rel/dl_interval_relation.h"
#include "ast/arith_decl_plugin.h"
#include "ast/rewriter/bool_rewriter.h"
namespace datalog {
@ -44,7 +44,7 @@ namespace datalog {
class filter_interpreted_fn;
class filter_intersection_fn;
arith_util m_arith;
basic_simplifier_plugin m_bsimp;
bool_rewriter m_bsimp;
public:
bound_relation_plugin(relation_manager& m);
virtual bool can_handle_signature(const relation_signature & s);

4
src/muz/rel/dl_check_table.cpp
View file

@ -19,8 +19,8 @@ Revision History:
--*/
#include "dl_check_table.h"
#include "dl_table.h"
#include "muz/rel/dl_check_table.h"
#include "muz/rel/dl_table.h"
namespace datalog {

6
src/muz/rel/dl_check_table.h
View file

@ -21,9 +21,9 @@ Revision History:
#ifndef DL_CHECK_TABLE_H_
#define DL_CHECK_TABLE_H_
#include "dl_base.h"
#include "dl_decl_plugin.h"
#include "dl_relation_manager.h"
#include "muz/rel/dl_base.h"
#include "ast/dl_decl_plugin.h"
#include "muz/rel/dl_relation_manager.h"
namespace datalog {
class check_table;

16
src/muz/rel/dl_compiler.cpp
View file

@ -19,15 +19,15 @@ Revision History:
#include <sstream>
#include"ref_vector.h"
#include"dl_context.h"
#include"rel_context.h"
#include"dl_rule.h"
#include"dl_util.h"
#include"dl_compiler.h"
#include"ast_pp.h"
#include "util/ref_vector.h"
#include "muz/base/dl_context.h"
#include "muz/rel/rel_context.h"
#include "muz/base/dl_rule.h"
#include "muz/base/dl_util.h"
#include "muz/rel/dl_compiler.h"
#include "ast/ast_pp.h"
// include"ast_smt2_pp.h"
#include"ast_util.h"
#include "ast/ast_util.h"
namespace datalog {

18
src/muz/rel/dl_compiler.h
View file

@ -23,16 +23,16 @@ Revision History:
#include<list>
#include<utility>
#include "ast.h"
#include "hashtable.h"
#include "map.h"
#include "obj_pair_hashtable.h"
#include "ref_vector.h"
#include "vector.h"
#include "ast/ast.h"
#include "util/hashtable.h"
#include "util/map.h"
#include "util/obj_pair_hashtable.h"
#include "util/ref_vector.h"
#include "util/vector.h"
#include "dl_base.h"
#include "dl_context.h"
#include "dl_instruction.h"
#include "muz/rel/dl_base.h"
#include "muz/base/dl_context.h"
#include "muz/rel/dl_instruction.h"
namespace datalog {

10
src/muz/rel/dl_external_relation.cpp
View file

@ -17,11 +17,11 @@ Revision History:
--*/
#include "debug.h"
#include "ast_pp.h"
#include "dl_context.h"
#include "dl_external_relation.h"
#include "dl_decl_plugin.h"
#include "util/debug.h"
#include "ast/ast_pp.h"
#include "muz/base/dl_context.h"
#include "muz/rel/dl_external_relation.h"
#include "ast/dl_decl_plugin.h"
namespace datalog {

2
src/muz/rel/dl_external_relation.h
View file

@ -19,7 +19,7 @@ Revision History:
#ifndef DL_EXTERNAL_RELATION_H_
#define DL_EXTERNAL_RELATION_H_
#include "dl_base.h"
#include "muz/rel/dl_base.h"
namespace datalog {

10
src/muz/rel/dl_finite_product_relation.cpp
View file

@ -19,11 +19,11 @@ Revision History:
#include<string>
#include"dl_context.h"
#include"dl_relation_manager.h"
#include"dl_table_relation.h"
#include"dl_finite_product_relation.h"
#include"bool_rewriter.h"
#include "muz/base/dl_context.h"
#include "muz/rel/dl_relation_manager.h"
#include "muz/rel/dl_table_relation.h"
#include "muz/rel/dl_finite_product_relation.h"
#include "ast/rewriter/bool_rewriter.h"
namespace datalog {

6
src/muz/rel/dl_finite_product_relation.h
View file

@ -20,9 +20,9 @@ Revision History:
#define DL_FINITE_PRODUCT_RELATION_H_
#include "dl_base.h"
#include "dl_relation_manager.h"
#include "dl_table_relation.h"
#include "muz/rel/dl_base.h"
#include "muz/rel/dl_relation_manager.h"
#include "muz/rel/dl_table_relation.h"
namespace datalog {

16
src/muz/rel/dl_instruction.cpp
View file

@ -17,14 +17,14 @@ Revision History:
--*/
#include"ast_pp.h"
#include"stopwatch.h"
#include"dl_context.h"
#include"dl_util.h"
#include"dl_instruction.h"
#include"rel_context.h"
#include"debug.h"
#include"warning.h"
#include "ast/ast_pp.h"
#include "util/stopwatch.h"
#include "muz/base/dl_context.h"
#include "muz/base/dl_util.h"
#include "muz/rel/dl_instruction.h"
#include "muz/rel/rel_context.h"
#include "util/debug.h"
#include "util/warning.h"
namespace datalog {

10
src/muz/rel/dl_instruction.h
View file

@ -22,11 +22,11 @@ Revision History:
#include<iostream>
#include<string>
#include<utility>
#include "ast.h"
#include "vector.h"
#include "dl_base.h"
#include "dl_costs.h"
#include "dl_context.h"
#include "ast/ast.h"
#include "util/vector.h"
#include "muz/rel/dl_base.h"
#include "muz/base/dl_costs.h"
#include "muz/base/dl_context.h"
namespace datalog {

11
src/muz/rel/dl_interval_relation.cpp
View file

@ -17,12 +17,11 @@ Revision History:
--*/
#include "debug.h"
#include "optional.h"
#include "ast_pp.h"
#include "dl_interval_relation.h"
#include "dl_relation_manager.h"
#include "bool_rewriter.h"
#include "util/debug.h"
#include "ast/ast_pp.h"
#include "muz/rel/dl_interval_relation.h"
#include "muz/rel/dl_relation_manager.h"
#include "ast/rewriter/bool_rewriter.h"
namespace datalog {

13
src/muz/rel/dl_interval_relation.h
View file

@ -20,13 +20,12 @@ Revision History:
#define DL_INTERVAL_RELATION_H_
#include "dl_context.h"
#include "dl_relation_manager.h"
#include "dl_base.h"
#include "old_interval.h"
#include "dl_vector_relation.h"
#include "arith_decl_plugin.h"
#include "basic_simplifier_plugin.h"
#include "ast/arith_decl_plugin.h"
#include "smt/old_interval.h"
#include "muz/base/dl_context.h"
#include "muz/rel/dl_relation_manager.h"
#include "muz/rel/dl_base.h"
#include "muz/rel/dl_vector_relation.h"
namespace datalog {

4
src/muz/rel/dl_lazy_table.cpp
View file

@ -17,8 +17,8 @@ Revision History:
--*/
#include "dl_lazy_table.h"
#include "dl_relation_manager.h"
#include "muz/rel/dl_lazy_table.h"
#include "muz/rel/dl_relation_manager.h"
#include <sstream>
namespace datalog {

4
src/muz/rel/dl_lazy_table.h
View file

@ -21,8 +21,8 @@ Revision History:
#ifndef DL_LAZY_TABLE_H_
#define DL_LAZY_TABLE_H_
#include "dl_base.h"
#include "ref.h"
#include "muz/rel/dl_base.h"
#include "util/ref.h"
namespace datalog {

12
src/muz/rel/dl_mk_explanations.cpp
View file

@ -19,12 +19,12 @@ Revision History:
#include <sstream>
#include"ast_pp.h"
#include"ast_smt_pp.h"
#include"dl_finite_product_relation.h"
#include"dl_product_relation.h"
#include"dl_sieve_relation.h"
#include"dl_mk_explanations.h"
#include "ast/ast_pp.h"
#include "ast/ast_smt_pp.h"
#include "muz/rel/dl_finite_product_relation.h"
#include "muz/rel/dl_product_relation.h"
#include "muz/rel/dl_sieve_relation.h"
#include "muz/rel/dl_mk_explanations.h"
namespace datalog {

4
src/muz/rel/dl_mk_explanations.h
View file

@ -20,8 +20,8 @@ Revision History:
#ifndef DL_MK_EXPLANATIONS_H_
#define DL_MK_EXPLANATIONS_H_
#include "dl_context.h"
#include "dl_rule_transformer.h"
#include "muz/base/dl_context.h"
#include "muz/base/dl_rule_transformer.h"
namespace datalog {

4
src/muz/rel/dl_mk_similarity_compressor.cpp
View file

@ -19,8 +19,8 @@ Revision History:
#include<utility>
#include<sstream>
#include"dl_mk_similarity_compressor.h"
#include"dl_relation_manager.h"
#include "muz/rel/dl_mk_similarity_compressor.h"
#include "muz/rel/dl_relation_manager.h"
namespace datalog {

10
src/muz/rel/dl_mk_similarity_compressor.h
View file

@ -21,12 +21,12 @@ Revision History:
#include<utility>
#include"map.h"
#include"obj_pair_hashtable.h"
#include "util/map.h"
#include "util/obj_pair_hashtable.h"
#include"dl_context.h"
#include"dl_rule_set.h"
#include"dl_rule_transformer.h"
#include "muz/base/dl_context.h"
#include "muz/base/dl_rule_set.h"
#include "muz/base/dl_rule_transformer.h"
namespace datalog {

8
src/muz/rel/dl_mk_simple_joins.cpp
View file

@ -20,10 +20,10 @@ Revision History:
#include<utility>
#include<sstream>
#include<limits>
#include"dl_mk_simple_joins.h"
#include"dl_relation_manager.h"
#include"ast_pp.h"
#include"trace.h"
#include "muz/rel/dl_mk_simple_joins.h"
#include "muz/rel/dl_relation_manager.h"
#include "ast/ast_pp.h"
#include "util/trace.h"
namespace datalog {

10
src/muz/rel/dl_mk_simple_joins.h
View file

@ -19,12 +19,12 @@ Revision History:
#ifndef DL_MK_SIMPLE_JOINS_H_
#define DL_MK_SIMPLE_JOINS_H_
#include"map.h"
#include"obj_pair_hashtable.h"
#include "util/map.h"
#include "util/obj_pair_hashtable.h"
#include"dl_context.h"
#include"dl_rule_set.h"
#include"dl_rule_transformer.h"
#include "muz/base/dl_context.h"
#include "muz/base/dl_rule_set.h"
#include "muz/base/dl_rule_transformer.h"
namespace datalog {

10
src/muz/rel/dl_product_relation.cpp
View file

@ -42,11 +42,11 @@ Notes:
--*/
#include "dl_sieve_relation.h"
#include "dl_table_relation.h"
#include "dl_product_relation.h"
#include "bool_rewriter.h"
#include "ast_pp.h"
#include "muz/rel/dl_sieve_relation.h"
#include "muz/rel/dl_table_relation.h"
#include "muz/rel/dl_product_relation.h"
#include "ast/rewriter/bool_rewriter.h"
#include "ast/ast_pp.h"
namespace datalog {

4
src/muz/rel/dl_product_relation.h
View file

@ -20,8 +20,8 @@ Revision History:
#define DL_PRODUCT_RELATION_H_
#include "dl_context.h"
#include "dl_relation_manager.h"
#include "muz/base/dl_context.h"
#include "muz/rel/dl_relation_manager.h"
namespace datalog {

16
src/muz/rel/dl_relation_manager.cpp
View file

@ -19,14 +19,14 @@ Revision History:
#include <sstream>
#include"ast_pp.h"
#include"dl_check_table.h"
#include"dl_context.h"
#include"dl_finite_product_relation.h"
#include"dl_product_relation.h"
#include"dl_sieve_relation.h"
#include"dl_table_relation.h"
#include"dl_relation_manager.h"
#include "ast/ast_pp.h"
#include "muz/rel/dl_check_table.h"
#include "muz/base/dl_context.h"
#include "muz/rel/dl_finite_product_relation.h"
#include "muz/rel/dl_product_relation.h"
#include "muz/rel/dl_sieve_relation.h"
#include "muz/rel/dl_table_relation.h"
#include "muz/rel/dl_relation_manager.h"
namespace datalog {

6
src/muz/rel/dl_relation_manager.h
View file

@ -20,9 +20,9 @@ Revision History:
#define DL_RELATION_MANAGER_H_
#include"map.h"
#include"vector.h"
#include"dl_base.h"
#include "util/map.h"
#include "util/vector.h"
#include "muz/rel/dl_base.h"
namespace datalog {

4
src/muz/rel/dl_sieve_relation.cpp
View file

@ -18,8 +18,8 @@ Revision History:
--*/
#include <sstream>
#include"ast_pp.h"
#include"dl_sieve_relation.h"
#include "ast/ast_pp.h"
#include "muz/rel/dl_sieve_relation.h"
namespace datalog {

Some files were not shown because too many files have changed in this diff Show more